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.Buffer.fst | FStar.Buffer.create | val create: #a:Type -> init:a -> len:UInt32.t -> StackInline (buffer a)
(requires (fun h -> True))
(ensures (fun (h0:mem) b h1 -> b `unused_in` h0
/\ live h1 b /\ idx b == 0 /\ length b == v len
/\ frameOf b == HS.get_tip h0
/\ Map.domain (HS.get_hmap h1) == Map.domain (HS.get_hmap h0)
/\ modifi... | val create: #a:Type -> init:a -> len:UInt32.t -> StackInline (buffer a)
(requires (fun h -> True))
(ensures (fun (h0:mem) b h1 -> b `unused_in` h0
/\ live h1 b /\ idx b == 0 /\ length b == v len
/\ frameOf b == HS.get_tip h0
/\ Map.domain (HS.get_hmap h1) == Map.domain (HS.get_hmap h0)
/\ modifi... | let create #a init len =
let content: reference (lseq a (v len)) =
salloc (Seq.create (v len) init) in
let b = MkBuffer len content 0ul len in
let h = HST.get() in
assert (Seq.equal (as_seq h b) (sel h b));
b | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 822,
"start_col": 0,
"start_line": 816
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | init: a -> len: FStar.UInt32.t -> FStar.HyperStack.ST.StackInline (FStar.Buffer.buffer a) | FStar.HyperStack.ST.StackInline | [] | [] | [
"FStar.UInt32.t",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Buffer.as_seq",
"FStar.Buffer.sel",
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Buffer._buffer",
"FStar.Buffer.MkBuffer",
"FStar.UInt32.__uint_to_t",
"FStar.HyperSta... | [] | false | true | false | false | false | let create #a init len =
| let content:reference (lseq a (v len)) = salloc (Seq.create (v len) init) in
let b = MkBuffer len content 0ul len in
let h = HST.get () in
assert (Seq.equal (as_seq h b) (sel h b));
b | false |
FStar.Buffer.fst | FStar.Buffer.index | val index: #a:Type -> b:buffer a -> n:UInt32.t{v n < length b} -> Stack a
(requires (fun h -> live h b))
(ensures (fun h0 z h1 -> live h0 b /\ h1 == h0
/\ z == Seq.index (as_seq h0 b) (v n))) | val index: #a:Type -> b:buffer a -> n:UInt32.t{v n < length b} -> Stack a
(requires (fun h -> live h b))
(ensures (fun h0 z h1 -> live h0 b /\ h1 == h0
/\ z == Seq.index (as_seq h0 b) (v n))) | let index #a b n =
let s = !b.content in
Seq.index s (v b.idx + v n) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 964,
"start_col": 0,
"start_line": 962
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer a -> n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b}
-> FStar.HyperStack.ST.Stack a | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Seq.Base.index",
"Prims.op_Addition",
"FStar.Buffer.__proj__MkBuffer__item__idx",
"FStar.Buffer.lseq",
"FStar.Buffer.__proj__MkBuffer__item__max_length",
"FStar.HyperStack... | [] | false | true | false | false | false | let index #a b n =
| let s = !b.content in
Seq.index s (v b.idx + v n) | false |
FStar.Buffer.fst | FStar.Buffer.to_seq_full | val to_seq_full: #a:Type -> b:buffer a -> ST (seq a)
(requires (fun h -> live h b))
(ensures (fun h0 r h1 -> h0 == h1 /\ live h1 b /\
r == as_seq #a h1 b )) | val to_seq_full: #a:Type -> b:buffer a -> ST (seq a)
(requires (fun h -> live h b))
(ensures (fun h0 r h1 -> h0 == h1 /\ live h1 b /\
r == as_seq #a h1 b )) | let to_seq_full #a b =
let s = !b.content in
let i = v b.idx in
Seq.slice s i (i + v b.length) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 32,
"end_line": 956,
"start_col": 0,
"start_line": 953
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer a -> FStar.HyperStack.ST.ST (FStar.Seq.Base.seq a) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Buffer.buffer",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Buffer.__proj__MkBuffer__item__length",
"FStar.UInt.uint_t",
"FStar.Buffer.__proj__MkBuffer__item__idx",
"FStar.Seq.Base.seq",
"FStar.Buffer.lseq",
"FStar.Buffer.__proj__MkBuffer__item__max_length",
"FSt... | [] | false | true | false | false | false | let to_seq_full #a b =
| let s = !b.content in
let i = v b.idx in
Seq.slice s i (i + v b.length) | false |
FStar.Buffer.fst | FStar.Buffer.rcreate | val rcreate: #a:Type -> r:rid -> init:a -> len:UInt32.t -> ST (buffer a)
(requires (fun h -> is_eternal_region r))
(ensures (fun (h0:mem) b h1 -> rcreate_post_common r init len b h0 h1 /\ ~(is_mm b.content))) | val rcreate: #a:Type -> r:rid -> init:a -> len:UInt32.t -> ST (buffer a)
(requires (fun h -> is_eternal_region r))
(ensures (fun (h0:mem) b h1 -> rcreate_post_common r init len b h0 h1 /\ ~(is_mm b.content))) | let rcreate #a r init len = rcreate_common r init len false | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 898,
"start_col": 0,
"start_line": 898
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t
-> FStar.HyperStack.ST.ST (FStar.Buffer.buffer a) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"FStar.Buffer.rcreate_common",
"FStar.Buffer.buffer"
] | [] | false | true | false | false | false | let rcreate #a r init len =
| rcreate_common r init len false | false |
FStar.Buffer.fst | FStar.Buffer.createL | val createL: #a:Type0 -> init:list a -> StackInline (buffer a)
(requires (fun h -> p #a init))
(ensures (fun (h0:mem) b h1 ->
let len = FStar.List.Tot.length init in
len > 0
/\ b `unused_in` h0
/\ live h1 b /\ idx b == 0 /\ length b == len
/\ frameOf b == (HS.get_tip h0)
/\ Map.domain ... | val createL: #a:Type0 -> init:list a -> StackInline (buffer a)
(requires (fun h -> p #a init))
(ensures (fun (h0:mem) b h1 ->
let len = FStar.List.Tot.length init in
len > 0
/\ b `unused_in` h0
/\ live h1 b /\ idx b == 0 /\ length b == len
/\ frameOf b == (HS.get_tip h0)
/\ Map.domain ... | let createL #a init =
let len = UInt32.uint_to_t (FStar.List.Tot.length init) in
let s = Seq.seq_of_list init in
let content: reference (lseq a (v len)) =
salloc (Seq.seq_of_list init) in
let b = MkBuffer len content 0ul len in
let h = HST.get() in
assert (Seq.equal (as_seq h b) (sel h b));
b | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 856,
"start_col": 0,
"start_line": 848
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"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 | init: Prims.list a -> FStar.HyperStack.ST.StackInline (FStar.Buffer.buffer a) | FStar.HyperStack.ST.StackInline | [] | [] | [
"Prims.list",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Buffer.as_seq",
"FStar.Buffer.sel",
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Buffer._buffer",
"FStar.Buffer.MkBuffer",
"FStar.UInt32.__uint_to_t",
"FStar.HyperStack.S... | [] | false | true | false | false | false | let createL #a init =
| let len = UInt32.uint_to_t (FStar.List.Tot.length init) in
let s = Seq.seq_of_list init in
let content:reference (lseq a (v len)) = salloc (Seq.seq_of_list init) in
let b = MkBuffer len content 0ul len in
let h = HST.get () in
assert (Seq.equal (as_seq h b) (sel h b));
b | false |
FStar.Buffer.fst | FStar.Buffer.rfree | val rfree (#a: Type) (b: buffer a)
: ST unit
(requires (fun h0 -> live h0 b /\ freeable b))
(ensures
(fun h0 _ h1 ->
is_mm (content b) /\ is_eternal_region (frameOf b) /\ h1 == HS.free (content b) h0)) | val rfree (#a: Type) (b: buffer a)
: ST unit
(requires (fun h0 -> live h0 b /\ freeable b))
(ensures
(fun h0 _ h1 ->
is_mm (content b) /\ is_eternal_region (frameOf b) /\ h1 == HS.free (content b) h0)) | let rfree (#a:Type) (b:buffer a)
:ST unit (requires (fun h0 -> live h0 b /\ freeable b))
(ensures (fun h0 _ h1 -> is_mm (content b) /\ is_eternal_region (frameOf b) /\ h1 == HS.free (content b) h0))
= rfree b.content | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 921,
"start_col": 0,
"start_line": 918
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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: FStar.Buffer.buffer a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Buffer.buffer",
"FStar.HyperStack.ST.rfree",
"FStar.Buffer.lseq",
"FStar.UInt32.v",
"FStar.Buffer.__proj__MkBuffer__item__max_length",
"FStar.Heap.trivial_preorder",
"FStar.Buffer.__proj__MkBuffer__item__content",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"FStar.Buffe... | [] | false | true | false | false | false | let rfree (#a: Type) (b: buffer a)
: ST unit
(requires (fun h0 -> live h0 b /\ freeable b))
(ensures
(fun h0 _ h1 ->
is_mm (content b) /\ is_eternal_region (frameOf b) /\ h1 == HS.free (content b) h0)) =
| rfree b.content | false |
FStar.Buffer.fst | FStar.Buffer.rcreate_common | val rcreate_common (#a: Type) (r: rid) (init: a) (len: UInt32.t) (mm: bool)
: ST (buffer a)
(requires (fun h0 -> is_eternal_region r))
(ensures (fun h0 b h1 -> rcreate_post_common r init len b h0 h1 /\ is_mm b.content == mm)) | val rcreate_common (#a: Type) (r: rid) (init: a) (len: UInt32.t) (mm: bool)
: ST (buffer a)
(requires (fun h0 -> is_eternal_region r))
(ensures (fun h0 b h1 -> rcreate_post_common r init len b h0 h1 /\ is_mm b.content == mm)) | let rcreate_common (#a:Type) (r:rid) (init:a) (len:UInt32.t) (mm:bool)
:ST (buffer a) (requires (fun h0 -> is_eternal_region r))
(ensures (fun h0 b h1 -> rcreate_post_common r init len b h0 h1 /\
is_mm b.content == mm))
= let h0 = HST.get() in
let s = Seq.create ... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 889,
"start_col": 8,
"start_line": 876
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | r: FStar.Monotonic.HyperHeap.rid -> init: a -> len: FStar.UInt32.t -> mm: Prims.bool
-> FStar.HyperStack.ST.ST (FStar.Buffer.buffer a) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.HyperHeap.rid",
"FStar.UInt32.t",
"Prims.bool",
"Prims.unit",
"FStar.Buffer.lemma_upd",
"FStar.Buffer.lseq",
"FStar.UInt32.v",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Buffer.as_seq",
"FStar.Buffer.sel",
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FSta... | [] | false | true | false | false | false | let rcreate_common (#a: Type) (r: rid) (init: a) (len: UInt32.t) (mm: bool)
: ST (buffer a)
(requires (fun h0 -> is_eternal_region r))
(ensures (fun h0 b h1 -> rcreate_post_common r init len b h0 h1 /\ is_mm b.content == mm)) =
| let h0 = HST.get () in
let s = Seq.create (v len) init in
let content:reference (lseq a (v len)) = if mm then ralloc_mm r s else ralloc r s in
let b = MkBuffer len content 0ul len in
let h1 = HST.get () in
assert (Seq.equal (as_seq h1 b) (sel h1 b));
lemma_upd h0 content s;
b | false |
FStar.Buffer.fst | FStar.Buffer.lemma_aux_0 | val lemma_aux_0
(#a: Type)
(b: buffer a)
(n: UInt32.t{v n < length b})
(z: a)
(h0: mem)
(tt: Type)
(bb: buffer tt)
: Lemma (requires (live h0 b /\ live h0 bb /\ disjoint b bb))
(ensures
(live h0 b /\ live h0 bb /\
(let h1 = HS.upd h0 b.content (Seq.u... | val lemma_aux_0
(#a: Type)
(b: buffer a)
(n: UInt32.t{v n < length b})
(z: a)
(h0: mem)
(tt: Type)
(bb: buffer tt)
: Lemma (requires (live h0 b /\ live h0 bb /\ disjoint b bb))
(ensures
(live h0 b /\ live h0 bb /\
(let h1 = HS.upd h0 b.content (Seq.u... | let lemma_aux_0
(#a:Type) (b:buffer a) (n:UInt32.t{v n < length b}) (z:a) (h0:mem) (tt:Type) (bb:buffer tt)
:Lemma (requires (live h0 b /\ live h0 bb /\ disjoint b bb))
(ensures (live h0 b /\ live h0 bb /\
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) z) in
as_seq h0 ... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 975,
"start_col": 8,
"start_line": 968
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b} ->
z: a ->
h0: FStar.Monotonic.HyperStack.mem ->
tt: Type0 ->
bb: FStar.Buffer.buffer tt
-> FStar.Pervasives.Lemma
(requires FStar.Buffer.live h0 b /\ FStar.Buffer.live h0 bb /\ FStar.Buffer.disjoint... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Heap.lemma_distinct_addrs_distinct_mm",
"Prims.unit",
"FStar.Monotonic.Heap.lemma_distinct_addrs_distinct_preorders",
"Prims.l_an... | [] | true | false | true | false | false | let lemma_aux_0
(#a: Type)
(b: buffer a)
(n: UInt32.t{v n < length b})
(z: a)
(h0: mem)
(tt: Type)
(bb: buffer tt)
: Lemma (requires (live h0 b /\ live h0 bb /\ disjoint b bb))
(ensures
(live h0 b /\ live h0 bb /\
(let h1 = HS.upd h0 b.content (Seq.u... | Heap.lemma_distinct_addrs_distinct_preorders ();
Heap.lemma_distinct_addrs_distinct_mm () | false |
FStar.Buffer.fst | FStar.Buffer.lemma_aux | val lemma_aux: #a:Type -> b:buffer a -> n:UInt32.t{v n < length b} -> z:a
-> h0:mem -> Lemma
(requires (live h0 b))
(ensures (live h0 b
/\ modifies_1 b h0 (HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) z)) ))
[SMTPat (HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) z))] | val lemma_aux: #a:Type -> b:buffer a -> n:UInt32.t{v n < length b} -> z:a
-> h0:mem -> Lemma
(requires (live h0 b))
(ensures (live h0 b
/\ modifies_1 b h0 (HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) z)) ))
[SMTPat (HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) z))] | let lemma_aux #a b n z h0 = lemma_aux_2 b n z h0 | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 1006,
"start_col": 0,
"start_line": 1006
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b} ->
z: a ->
h0: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.live h0 b)
(ensures
FStar.Buffer.live h0 b /\
FStar.Buffer.modifies_1 b
h0
(... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"FStar.Buffer.lemma_aux_2",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_aux #a b n z h0 =
| lemma_aux_2 b n z h0 | false |
FStar.Buffer.fst | FStar.Buffer.to_seq | val to_seq: #a:Type -> b:buffer a -> l:UInt32.t{v l <= length b} -> STL (seq a)
(requires (fun h -> live h b))
(ensures (fun h0 r h1 -> h0 == h1 /\ live h1 b /\ Seq.length r == v l
(*/\ r == as_seq #a h1 b *) )) | val to_seq: #a:Type -> b:buffer a -> l:UInt32.t{v l <= length b} -> STL (seq a)
(requires (fun h -> live h b))
(ensures (fun h0 r h1 -> h0 == h1 /\ live h1 b /\ Seq.length r == v l
(*/\ r == as_seq #a h1 b *) )) | let to_seq #a b l =
let s = !b.content in
let i = v b.idx in
Seq.slice s i (i + v l) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 945,
"start_col": 0,
"start_line": 942
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer a -> l: FStar.UInt32.t{FStar.UInt32.v l <= FStar.Buffer.length b}
-> FStar.HyperStack.ST.STL (FStar.Seq.Base.seq a) | FStar.HyperStack.ST.STL | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt.uint_t",
"FStar.Buffer.__proj__MkBuffer__item__idx",
"FStar.Seq.Base.seq",
"FStar.Buffer.lseq",
"FStar.Buffer.__... | [] | false | true | false | false | false | let to_seq #a b l =
| let s = !b.content in
let i = v b.idx in
Seq.slice s i (i + v l) | false |
FStar.Buffer.fst | FStar.Buffer.lemma_aux_1 | val lemma_aux_1 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem) (tt: Type)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | val lemma_aux_1 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem) (tt: Type)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | let lemma_aux_1
(#a:Type) (b:buffer a) (n:UInt32.t{v n < length b}) (z:a) (h0:mem) (tt:Type)
:Lemma (requires (live h0 b))
(ensures (live h0 b /\
(forall (bb:buffer tt). (live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (idx b + v n) ... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 986,
"start_col": 8,
"start_line": 978
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b} ->
z: a ->
h0: FStar.Monotonic.HyperStack.mem ->
tt: Type0
-> FStar.Pervasives.Lemma (requires FStar.Buffer.live h0 b)
(ensures
FStar.Buffer.live h0 b /\
(forall (bb: FStar.Buffer.buffer ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"Prims.l_and",
"FStar.Buffer.live",
"FStar.Buffer.disjoint",
"Prims.eq2",
"FStar.Seq.Base.seq... | [] | false | false | true | false | false | let lemma_aux_1 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem) (tt: Type)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | let open FStar.Classical in forall_intro (move_requires (lemma_aux_0 b n z h0 tt)) | false |
FStar.Buffer.fst | FStar.Buffer.offset | val offset: #a:Type -> b:buffer a
-> i:UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length}
-> Tot (b':buffer a{b `includes` b'}) | val offset: #a:Type -> b:buffer a
-> i:UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length}
-> Tot (b':buffer a{b `includes` b'}) | let offset #a b i =
MkBuffer b.max_length b.content (i +^ b.idx) (b.length -^ i) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 1072,
"start_col": 0,
"start_line": 1071
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
i:
FStar.UInt32.t
{ FStar.UInt32.v i + FStar.UInt32.v (MkBuffer?.idx b) < Prims.pow2 FStar.UInt32.n /\
FStar.UInt32.v i <= FStar.UInt32.v (MkBuffer?.length b) }
-> b': FStar.Buffer.buffer a {FStar.Buffer.includes b b'} | Prims.Tot | [
"total"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Buffer.__proj__MkBuffer__item__idx",
"Prims.pow2",
"FStar.UInt32.n",
"Prims.op_LessThanOrEqual",
"FStar.Buffer.__proj__MkBuffer__item__length",
"FStar.Buffe... | [] | false | false | false | false | false | let offset #a b i =
| MkBuffer b.max_length b.content (i +^ b.idx) (b.length -^ i) | false |
FStar.Buffer.fst | FStar.Buffer.upd | val upd: #a:Type -> b:buffer a -> n:UInt32.t -> z:a -> Stack unit
(requires (fun h -> live h b /\ v n < length b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ v n < length b
/\ modifies_1 b h0 h1
/\ as_seq h1 b == Seq.upd (as_seq h0 b) (v n) z )) | val upd: #a:Type -> b:buffer a -> n:UInt32.t -> z:a -> Stack unit
(requires (fun h -> live h b /\ v n < length b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ v n < length b
/\ modifies_1 b h0 h1
/\ as_seq h1 b == Seq.upd (as_seq h0 b) (v n) z )) | let upd #a b n z =
let h0 = HST.get () in
let s0 = !b.content in
let s = Seq.upd s0 (v b.idx + v n) z in
b.content := s;
lemma_aux b n z h0;
let h = HST.get() in
Seq.lemma_eq_intro (as_seq h b) (Seq.slice s (idx b) (idx b + length b));
Seq.upd_slice s0 (idx b) (idx b + length b) (v n) z | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 1021,
"start_col": 0,
"start_line": 1013
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer a -> n: FStar.UInt32.t -> z: a -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"FStar.Seq.Properties.upd_slice",
"FStar.Buffer.idx",
"Prims.op_Addition",
"FStar.Buffer.length",
"FStar.UInt32.v",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Buffer.as_seq",
"FStar.Seq.Base.slice",
"FStar.Monotonic.HyperStack.mem",
"FStar.... | [] | false | true | false | false | false | let upd #a b n z =
| let h0 = HST.get () in
let s0 = !b.content in
let s = Seq.upd s0 (v b.idx + v n) z in
b.content := s;
lemma_aux b n z h0;
let h = HST.get () in
Seq.lemma_eq_intro (as_seq h b) (Seq.slice s (idx b) (idx b + length b));
Seq.upd_slice s0 (idx b) (idx b + length b) (v n) z | false |
FStar.Buffer.fst | FStar.Buffer.lemma_sub_spec' | val lemma_sub_spec'
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
(h: _)
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))... | val lemma_sub_spec'
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
(h: _)
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))... | let lemma_sub_spec' (#a:Type) (b:buffer a)
(i:UInt32.t)
(len:UInt32.t{v len <= length b /\ v i + v len <= length b})
h : Lemma
(requires (live h b))
(ensures (live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
[SMTPat (live h (sub b i len))]... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 1066,
"start_col": 0,
"start_line": 1058
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
i: FStar.UInt32.t ->
len:
FStar.UInt32.t
{ FStar.UInt32.v len <= FStar.Buffer.length b /\
FStar.UInt32.v i + FStar.UInt32.v len <= FStar.Buffer.length b } ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.live h b... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"Prims.op_Addition",
"FStar.Monotonic.HyperStack.mem",
"FStar.Buffer.lemma_sub_spec",
"Prims.unit",
"FStar.Buffer.live",
"Prims.squash",
"FStar.Buffer.s... | [] | true | false | true | false | false | let lemma_sub_spec'
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
h
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
... | lemma_sub_spec b i len h | false |
FStar.Buffer.fst | FStar.Buffer.op_Array_Access | val op_Array_Access: #a:Type -> b:buffer a -> n:UInt32.t{v n<length b} -> Stack a
(requires (fun h -> live h b))
(ensures (fun h0 z h1 -> h1 == h0
/\ z == Seq.index (as_seq h0 b) (v n))) | val op_Array_Access: #a:Type -> b:buffer a -> n:UInt32.t{v n<length b} -> Stack a
(requires (fun h -> live h b))
(ensures (fun h0 z h1 -> h1 == h0
/\ z == Seq.index (as_seq h0 b) (v n))) | let op_Array_Access #a b n = index #a b n | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 1140,
"start_col": 0,
"start_line": 1140
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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: FStar.Buffer.buffer a -> n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b}
-> FStar.HyperStack.ST.Stack a | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Buffer.index"
] | [] | false | true | false | false | false | let ( .() ) #a b n =
| index #a b n | false |
FStar.Buffer.fst | FStar.Buffer.sub | val sub: #a:Type -> b:buffer a -> i:UInt32.t
-> len:UInt32.t{v i + v len <= length b}
-> Tot (b':buffer a{b `includes` b' /\ length b' == v len}) | val sub: #a:Type -> b:buffer a -> i:UInt32.t
-> len:UInt32.t{v i + v len <= length b}
-> Tot (b':buffer a{b `includes` b' /\ length b' == v len}) | let sub #a b i len =
assert (v i + v b.idx < pow2 n); // was formerly a precondition
MkBuffer b.max_length b.content (i +^ b.idx) len | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 1028,
"start_col": 0,
"start_line": 1026
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
i: FStar.UInt32.t ->
len: FStar.UInt32.t{FStar.UInt32.v i + FStar.UInt32.v len <= FStar.Buffer.length b}
-> b':
FStar.Buffer.buffer a
{FStar.Buffer.includes b b' /\ FStar.Buffer.length b' == FStar.UInt32.v len} | Prims.Tot | [
"total"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Buffer.MkBuffer",
"FStar.Buffer.__proj__MkBuffer__item__max_length",
"FStar.Buffer.__proj__MkBuffer__item__content",
"FStar.UInt32.op_Plus_Hat",
... | [] | false | false | false | false | false | let sub #a b i len =
| assert (v i + v b.idx < pow2 n);
MkBuffer b.max_length b.content (i +^ b.idx) len | false |
FStar.Buffer.fst | FStar.Buffer.split | val split (#t: _) (b: buffer t) (i: UInt32.t{v i <= length b}) : Tot (buffer t * buffer t) | val split (#t: _) (b: buffer t) (i: UInt32.t{v i <= length b}) : Tot (buffer t * buffer t) | let split #t (b:buffer t) (i:UInt32.t{v i <= length b}) : Tot (buffer t * buffer t)
= sub b 0ul i, offset b i | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 1216,
"start_col": 0,
"start_line": 1215
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer t -> i: FStar.UInt32.t{FStar.UInt32.v i <= FStar.Buffer.length b}
-> FStar.Buffer.buffer t * FStar.Buffer.buffer t | Prims.Tot | [
"total"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Buffer.sub",
"FStar.UInt32.__uint_to_t",
"FStar.Buffer.offset",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let split #t (b: buffer t) (i: UInt32.t{v i <= length b}) : Tot (buffer t * buffer t) =
| sub b 0ul i, offset b i | false |
FStar.Buffer.fst | FStar.Buffer.lemma_offset_spec | val lemma_offset_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length})
(h: _)
: Lemma (requires True)
(ensures (as_seq h (offset b i) == Seq.slice (as_seq h b) (v i) (length b)))
[
SMTPatOr
[[SMTPat (as_seq h (offset b i))]; [SMT... | val lemma_offset_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length})
(h: _)
: Lemma (requires True)
(ensures (as_seq h (offset b i) == Seq.slice (as_seq h b) (v i) (length b)))
[
SMTPatOr
[[SMTPat (as_seq h (offset b i))]; [SMT... | let lemma_offset_spec (#a:Type) (b:buffer a)
(i:UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length})
h : Lemma
(requires True)
(ensures (as_seq h (offset b i) == Seq.slice (as_seq h b) (v i) (length b)))
[SMTPatOr [[SMTPat (as_seq h (offset b i))];
[SMTPat (Seq.slice (as_seq h b) (... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 1081,
"start_col": 0,
"start_line": 1074
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
i:
FStar.UInt32.t
{ FStar.UInt32.v i + FStar.UInt32.v (MkBuffer?.idx b) < Prims.pow2 FStar.UInt32.n /\
FStar.UInt32.v i <= FStar.UInt32.v (MkBuffer?.length b) } ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(ensures
FStar.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Buffer.__proj__MkBuffer__item__idx",
"Prims.pow2",
"FStar.UInt32.n",
"Prims.op_LessThanOrEqual",
"FStar.Buffer.__proj__MkBuffer__item__length",
"FStar.Monot... | [] | true | false | true | false | false | let lemma_offset_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t{v i + v b.idx < pow2 n /\ v i <= v b.length})
h
: Lemma (requires True)
(ensures (as_seq h (offset b i) == Seq.slice (as_seq h b) (v i) (length b)))
[
SMTPatOr
[[SMTPat (as_seq h (offset b i))]; [SMTPat (... | Seq.lemma_eq_intro (as_seq h (offset b i)) (Seq.slice (as_seq h b) (v i) (length b)) | false |
FStar.Buffer.fst | FStar.Buffer.lemma_aux_2 | val lemma_aux_2 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (tt: Type) (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | val lemma_aux_2 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (tt: Type) (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | let lemma_aux_2
(#a:Type) (b:buffer a) (n:UInt32.t{v n < length b}) (z:a) (h0:mem)
:Lemma (requires (live h0 b))
(ensures (live h0 b /\
(forall (tt:Type) (bb:buffer tt). (live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (idx... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 55,
"end_line": 998,
"start_col": 8,
"start_line": 990
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
n: FStar.UInt32.t{FStar.UInt32.v n < FStar.Buffer.length b} ->
z: a ->
h0: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.live h0 b)
(ensures
FStar.Buffer.live h0 b /\
(forall (tt: Type0) (bb: FStar.Buffer.buffer tt).
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Buffer.live",
"Prims.l_and",
"Prims.l_Forall",
"FStar.Buffer.disjoint",
"Prims.eq2",
... | [] | false | false | true | false | false | let lemma_aux_2 (#a: Type) (b: buffer a) (n: UInt32.t{v n < length b}) (z: a) (h0: mem)
: Lemma (requires (live h0 b))
(ensures
(live h0 b /\
(forall (tt: Type) (bb: buffer tt).
(live h0 bb /\ disjoint b bb) ==>
(let h1 = HS.upd h0 b.content (Seq.upd (sel h0 b) (i... | let open FStar.Classical in forall_intro (move_requires (lemma_aux_1 b n z h0)) | false |
FStar.Buffer.fst | FStar.Buffer.lemma_sub_spec | val lemma_sub_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
(h: _)
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
... | val lemma_sub_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
(h: _)
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
... | let lemma_sub_spec (#a:Type) (b:buffer a)
(i:UInt32.t)
(len:UInt32.t{v len <= length b /\ v i + v len <= length b})
h : Lemma
(requires (live h b))
(ensures (live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
[SMTPat (sub b i len); SMTPat (l... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 92,
"end_line": 1056,
"start_col": 0,
"start_line": 1048
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer a ->
i: FStar.UInt32.t ->
len:
FStar.UInt32.t
{ FStar.UInt32.v len <= FStar.Buffer.length b /\
FStar.UInt32.v i + FStar.UInt32.v len <= FStar.Buffer.length b } ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.live h b... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"Prims.op_Addition",
"FStar.Monotonic.HyperStack.mem",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Buffer.as_seq",
"FStar.Buffer.sub",
"FStar.Seq.Base.slice",... | [] | true | false | true | false | false | let lemma_sub_spec
(#a: Type)
(b: buffer a)
(i: UInt32.t)
(len: UInt32.t{v len <= length b /\ v i + v len <= length b})
h
: Lemma (requires (live h b))
(ensures
(live h (sub b i len) /\
as_seq h (sub b i len) == Seq.slice (as_seq h b) (v i) (v i + v len)))
... | Seq.lemma_eq_intro (as_seq h (sub b i len)) (Seq.slice (as_seq h b) (v i) (v i + v len)) | false |
FStar.Buffer.fst | FStar.Buffer.eq_lemma1 | val eq_lemma1:
#a:eqtype
-> b1:buffer a
-> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> h:mem
-> Lemma
(requires (forall (j:nat). j < v len ==> get h b1 j == get h b2 j))
(ensures equal h (sub b1 0ul len) h (sub b2 0ul len))
[SMTPat (equal h (sub b1 0ul len) h (sub... | val eq_lemma1:
#a:eqtype
-> b1:buffer a
-> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> h:mem
-> Lemma
(requires (forall (j:nat). j < v len ==> get h b1 j == get h b2 j))
(ensures equal h (sub b1 0ul len) h (sub b2 0ul len))
[SMTPat (equal h (sub b1 0ul len) h (sub... | let eq_lemma1 #a b1 b2 len h =
Seq.lemma_eq_intro (as_seq h (sub b1 0ul len)) (as_seq h (sub b2 0ul len)) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 1094,
"start_col": 0,
"start_line": 1093
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b1: FStar.Buffer.buffer a ->
b2: FStar.Buffer.buffer a ->
len:
FStar.UInt32.t
{ FStar.UInt32.v len <= FStar.Buffer.length b1 /\
FStar.UInt32.v len <= FStar.Buffer.length b2 } ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
forall (j: Prim... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Buffer.as_seq",
"FStar.Buffer.sub",
"FStar.UInt32.__uint_to_t",
... | [] | true | false | true | false | false | let eq_lemma1 #a b1 b2 len h =
| Seq.lemma_eq_intro (as_seq h (sub b1 0ul len)) (as_seq h (sub b2 0ul len)) | false |
FStar.Buffer.fst | FStar.Buffer.op_Array_Assignment | val op_Array_Assignment: #a:Type -> b:buffer a -> n:UInt32.t -> z:a -> Stack unit
(requires (fun h -> live h b /\ v n < length b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ v n < length b
/\ modifies_1 b h0 h1
/\ as_seq h1 b == Seq.upd (as_seq h0 b) (v n) z )) | val op_Array_Assignment: #a:Type -> b:buffer a -> n:UInt32.t -> z:a -> Stack unit
(requires (fun h -> live h b /\ v n < length b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ v n < length b
/\ modifies_1 b h0 h1
/\ as_seq h1 b == Seq.upd (as_seq h0 b) (v n) z )) | let op_Array_Assignment #a b n z = upd #a b n z | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 1147,
"start_col": 0,
"start_line": 1147
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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: FStar.Buffer.buffer a -> n: FStar.UInt32.t -> z: a -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"FStar.Buffer.upd",
"Prims.unit"
] | [] | false | true | false | false | false | let ( .()<- ) #a b n z =
| upd #a b n z | false |
FStar.Buffer.fst | FStar.Buffer.join | val join
(#t: _)
(b: buffer t)
(b':
buffer t
{ b.max_length == b'.max_length /\ b.content === b'.content /\
idx b + length b == idx b' })
: Tot (buffer t) | val join
(#t: _)
(b: buffer t)
(b':
buffer t
{ b.max_length == b'.max_length /\ b.content === b'.content /\
idx b + length b == idx b' })
: Tot (buffer t) | let join #t (b:buffer t) (b':buffer t{b.max_length == b'.max_length /\ b.content === b'.content /\ idx b + length b == idx b'}) : Tot (buffer t)
= MkBuffer (b.max_length) (b.content) (b.idx) (FStar.UInt32.(b.length +^ b'.length)) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 86,
"end_line": 1219,
"start_col": 0,
"start_line": 1218
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b: FStar.Buffer.buffer t ->
b':
FStar.Buffer.buffer t
{ MkBuffer?.max_length b == MkBuffer?.max_length b' /\
MkBuffer?.content b === MkBuffer?.content b' /\
FStar.Buffer.idx b + FStar.Buffer.length b == FStar.Buffer.idx b' }
-> FStar.Buffer.buffer t | Prims.Tot | [
"total"
] | [] | [
"FStar.Buffer.buffer",
"Prims.l_and",
"Prims.eq2",
"FStar.UInt32.t",
"FStar.Buffer.__proj__MkBuffer__item__max_length",
"Prims.op_Equals_Equals_Equals",
"FStar.HyperStack.ST.reference",
"FStar.Buffer.lseq",
"FStar.UInt32.v",
"FStar.Buffer.__proj__MkBuffer__item__content",
"Prims.int",
"Prims.o... | [] | false | false | false | false | false | let join
#t
(b: buffer t)
(b':
buffer t
{ b.max_length == b'.max_length /\ b.content === b'.content /\
idx b + length b == idx b' })
: Tot (buffer t) =
| MkBuffer (b.max_length) (b.content) (b.idx) (let open FStar.UInt32 in b.length +^ b'.length) | false |
FStar.Buffer.fst | FStar.Buffer.eq_lemma2 | val eq_lemma2:
#a:eqtype
-> b1:buffer a
-> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> h:mem
-> Lemma
(requires equal h (sub b1 0ul len) h (sub b2 0ul len))
(ensures (forall (j:nat). j < v len ==> get h b1 j == get h b2 j))
[SMTPat (equal h (sub b1 0ul len) h (sub... | val eq_lemma2:
#a:eqtype
-> b1:buffer a
-> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> h:mem
-> Lemma
(requires equal h (sub b1 0ul len) h (sub b2 0ul len))
(ensures (forall (j:nat). j < v len ==> get h b1 j == get h b2 j))
[SMTPat (equal h (sub b1 0ul len) h (sub... | let eq_lemma2 #a b1 b2 len h =
let s1 = as_seq h (sub b1 0ul len) in
let s2 = as_seq h (sub b2 0ul len) in
cut (forall (j:nat). j < v len ==> get h b1 j == Seq.index s1 j);
cut (forall (j:nat). j < v len ==> get h b2 j == Seq.index s2 j) | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 1112,
"start_col": 0,
"start_line": 1108
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b1: FStar.Buffer.buffer a ->
b2: FStar.Buffer.buffer a ->
len:
FStar.UInt32.t
{ FStar.UInt32.v len <= FStar.Buffer.length b1 /\
FStar.UInt32.v len <= FStar.Buffer.length b2 } ->
h: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires FStar.Buffer.equal h (F... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.eqtype",
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Monotonic.HyperStack.mem",
"Prims.cut",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.eq2",
"FSta... | [] | false | false | true | false | false | let eq_lemma2 #a b1 b2 len h =
| let s1 = as_seq h (sub b1 0ul len) in
let s2 = as_seq h (sub b2 0ul len) in
cut (forall (j: nat). j < v len ==> get h b1 j == Seq.index s1 j);
cut (forall (j: nat). j < v len ==> get h b2 j == Seq.index s2 j) | false |
Pulse.JoinComp.fst | Pulse.JoinComp.join_comps | val join_comps
(g_then:env)
(e_then:st_term)
(c_then:comp_st)
(e_then_typing:st_typing g_then e_then c_then)
(g_else:env)
(e_else:st_term)
(c_else:comp_st)
(e_else_typing:st_typing g_else e_else c_else)
(post:post_hint_t)
: TacS (c:comp_st &
st_typing g_then e_then c &
st_typing g_else... | val join_comps
(g_then:env)
(e_then:st_term)
(c_then:comp_st)
(e_then_typing:st_typing g_then e_then c_then)
(g_else:env)
(e_else:st_term)
(c_else:comp_st)
(e_else_typing:st_typing g_else e_else c_else)
(post:post_hint_t)
: TacS (c:comp_st &
st_typing g_then e_then c &
st_typing g_else... | let join_comps
(g_then:env)
(e_then:st_term)
(c_then:comp_st)
(e_then_typing:st_typing g_then e_then c_then)
(g_else:env)
(e_else:st_term)
(c_else:comp_st)
(e_else_typing:st_typing g_else e_else c_else)
(post:post_hint_t)
: TacS (c:comp_st &
st_typing g_then e_then c &
st_typing ... | {
"file_name": "lib/steel/pulse/Pulse.JoinComp.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 111,
"start_col": 0,
"start_line": 82
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Typing.Metatheory.fsti.checked",
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.Printer.fsti.checked",
"Pulse.Syntax.fst.checked",
"Pulse.RuntimeUtils.fsti.checked",
"Pulse.Checker.Pure.fsti.checked",
... | [
{
"abbrev": false,
"full_module": "Pulse.Checker.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "Pulse.RuntimeUtils",
"short_module": "RU"
},
{
"abbrev": true,
"full_module": "Pulse.Typing.Metatheory",
"short_module": "Metatheory"
},
{
"abbrev": t... | {
"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 |
g_then: Pulse.Typing.Env.env ->
e_then: Pulse.Syntax.Base.st_term ->
c_then: Pulse.Syntax.Base.comp_st ->
e_then_typing: Pulse.Typing.st_typing g_then e_then c_then ->
g_else: Pulse.Typing.Env.env ->
e_else: Pulse.Syntax.Base.st_term ->
c_else: Pulse.Syntax.Base.comp_st ->
e_else_typing... | Pulse.JoinComp.TacS | [] | [] | [
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.st_term",
"Pulse.Syntax.Base.comp_st",
"Pulse.Typing.st_typing",
"Pulse.Typing.post_hint_t",
"FStar.Pervasives.Native.Mktuple2",
"Pulse.Syntax.Base.comp",
"Pulse.Syntax.Base.term",
"Pulse.Syntax.Base.observability",
"Pulse.Syntax.Base.st_comp",
"FStar.P... | [] | false | true | false | false | false | let join_comps
(g_then: env)
(e_then: st_term)
(c_then: comp_st)
(e_then_typing: st_typing g_then e_then c_then)
(g_else: env)
(e_else: st_term)
(c_else: comp_st)
(e_else_typing: st_typing g_else e_else c_else)
(post: post_hint_t)
: TacS (c: comp_st & st_typing ... | let g = g_then in
assert (st_comp_of_comp c_then == st_comp_of_comp c_else);
match c_then, c_else with
| C_STAtomic _ obs1 _, C_STAtomic _ obs2 _ ->
let obs = join_obs obs1 obs2 in
let e_then_typing = T_Lift _ _ _ _ e_then_typing (Lift_Observability g_then c_then obs) in
let e_else_typing = T_Lift _ _ _ _ e_else_... | false |
FStar.Buffer.fst | FStar.Buffer.fill | val fill: #t:Type
-> b:buffer t
-> z:t
-> len:UInt32.t{v len <= length b}
-> Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ modifies_1 b h0 h1
/\ Seq.slice (as_seq h1 b) 0 (v len) == Seq.create (v len) z
/\ Seq.slice (as_seq h1 b) (v len) (lengt... | val fill: #t:Type
-> b:buffer t
-> z:t
-> len:UInt32.t{v len <= length b}
-> Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 -> live h0 b /\ live h1 b /\ modifies_1 b h0 h1
/\ Seq.slice (as_seq h1 b) 0 (v len) == Seq.create (v len) z
/\ Seq.slice (as_seq h1 b) (v len) (lengt... | let rec fill #t b z len =
let h0 = HST.get () in
if len =^ 0ul then ()
else
begin
let len' = len -^ 1ul in
fill #t b z len';
b.(len') <- z;
let h = HST.get() in
Seq.snoc_slice_index (as_seq h b) 0 (v len');
Seq.lemma_tail_slice (as_seq h b) (v len') (length b)
end;
let h1 = HST.g... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 79,
"end_line": 1212,
"start_col": 0,
"start_line": 1199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | b: FStar.Buffer.buffer t -> z: t -> len: FStar.UInt32.t{FStar.UInt32.v len <= FStar.Buffer.length b}
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Seq.Base.slice",
"FStar.Buffer.as_seq",
"FStar.Seq.Base.create",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStac... | [
"recursion"
] | false | true | false | false | false | let rec fill #t b z len =
| let h0 = HST.get () in
if len =^ 0ul
then ()
else
(let len' = len -^ 1ul in
fill #t b z len';
b.(len') <- z;
let h = HST.get () in
Seq.snoc_slice_index (as_seq h b) 0 (v len');
Seq.lemma_tail_slice (as_seq h b) (v len') (length b));
let h1 = HST.get () in
Seq.lemma_eq_intro (Seq.slice (as_seq h1 b... | false |
FStar.Buffer.fst | FStar.Buffer.eqb | val eqb: #a:eqtype -> b1:buffer a -> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> ST bool
(requires (fun h -> live h b1 /\ live h b2))
(ensures (fun h0 z h1 -> h1 == h0 /\
(z <==> equal h0 (sub b1 0ul len) h0 (sub b2 0ul len)))) | val eqb: #a:eqtype -> b1:buffer a -> b2:buffer a
-> len:UInt32.t{v len <= length b1 /\ v len <= length b2}
-> ST bool
(requires (fun h -> live h b1 /\ live h b2))
(ensures (fun h0 z h1 -> h1 == h0 /\
(z <==> equal h0 (sub b1 0ul len) h0 (sub b2 0ul len)))) | let rec eqb #a b1 b2 len =
if len =^ 0ul then true
else
let len' = len -^ 1ul in
if index b1 len' = index b2 len' then
eqb b1 b2 len'
else
false | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 11,
"end_line": 1128,
"start_col": 0,
"start_line": 1121
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 |
b1: FStar.Buffer.buffer a ->
b2: FStar.Buffer.buffer a ->
len:
FStar.UInt32.t
{ FStar.UInt32.v len <= FStar.Buffer.length b1 /\
FStar.UInt32.v len <= FStar.Buffer.length b2 }
-> FStar.HyperStack.ST.ST Prims.bool | FStar.HyperStack.ST.ST | [] | [] | [
"Prims.eqtype",
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.UInt32.op_Equals_Hat",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"FStar.Buffer.eqb",
"Prims.op_Equality",
"FStar.Buffer.index",
... | [
"recursion"
] | false | true | false | false | false | let rec eqb #a b1 b2 len =
| if len =^ 0ul
then true
else
let len' = len -^ 1ul in
if index b1 len' = index b2 len' then eqb b1 b2 len' else false | false |
FStar.Buffer.fst | FStar.Buffer.assignL | val assignL (#a: _) (l: list a) (b: buffer a)
: Stack unit
(requires (fun h0 -> live h0 b /\ length b = List.Tot.length l))
(ensures (fun h0 _ h1 -> live h1 b /\ modifies_1 b h0 h1 /\ as_seq h1 b == Seq.seq_of_list l)) | val assignL (#a: _) (l: list a) (b: buffer a)
: Stack unit
(requires (fun h0 -> live h0 b /\ length b = List.Tot.length l))
(ensures (fun h0 _ h1 -> live h1 b /\ modifies_1 b h0 h1 /\ as_seq h1 b == Seq.seq_of_list l)) | let rec assignL #a (l: list a) (b: buffer a): Stack unit
(requires (fun h0 ->
live h0 b /\
length b = List.Tot.length l))
(ensures (fun h0 _ h1 ->
live h1 b /\
modifies_1 b h0 h1 /\
as_seq h1 b == Seq.seq_of_list l))
= lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl ->
... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 1464,
"start_col": 0,
"start_line": 1444
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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 | l: Prims.list a -> b: FStar.Buffer.buffer a -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.list",
"FStar.Buffer.buffer",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Buffer.as_seq",
"FStar.Seq.Base.seq_of_list",
"FStar.Seq.Base.append",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Prims.l_or",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Seq.Base.length",
"... | [
"recursion"
] | false | true | false | false | false | let rec assignL #a (l: list a) (b: buffer a)
: Stack unit
(requires (fun h0 -> live h0 b /\ length b = List.Tot.length l))
(ensures (fun h0 _ h1 -> live h1 b /\ modifies_1 b h0 h1 /\ as_seq h1 b == Seq.seq_of_list l)) =
| lemma_seq_of_list_induction l;
match l with
| [] -> ()
| hd :: tl ->
let b_hd = sub b 0ul 1ul in
let b_tl = offset b 1ul in
b_hd.(0ul) <- hd;
assignL tl b_tl;
let h = HST.get () in
assert (get h b_hd 0 == hd);
assert (as_seq h b_tl == Seq.seq_of_list tl);
assert (Seq.equal (as_seq h b) (Seq.append (as_s... | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.lemma_proj_g_pow2_128_eval | val lemma_proj_g_pow2_128_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64 == proj_g_pow2_128) | val lemma_proj_g_pow2_128_eval : unit ->
Lemma (SE.exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64 == proj_g_pow2_128) | let lemma_proj_g_pow2_128_eval () =
SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64);
let rX : S.felem = 0... | {
"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": 79,
"start_col": 0,
"start_line": 72
} | 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_64
64 ==
Hacl.P256.PrecompTable.proj_g_pow2_128) | 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_128_eval () =
| SPT256.exp_pow2_rec_is_exp_pow2 S.mk_p256_concrete_ops proj_g_pow2_64 64;
let qX, qY, qZ = normalize_term (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64) in
normalize_term_spec (SPT256.exp_pow2_rec S.mk_p256_concrete_ops proj_g_pow2_64 64);
let rX:S.felem = 0x04c3aaf6c6c00704e96eda89461d63fd2c97ee1e6786f... | false |
Benton2004.RHL.fst | Benton2004.RHL.exec_equiv | val exec_equiv
(p p' : gexp bool)
(f f' : computation)
: GTot Type0 | val exec_equiv
(p p' : gexp bool)
(f f' : computation)
: GTot Type0 | let exec_equiv
(p p' : gexp bool)
(f f' : computation)
: GTot Type0
= Benton2004.exec_equiv (interp p) (interp p') f f' | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 54,
"start_col": 0,
"start_line": 50
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"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: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool ->
f: Benton2004.computation ->
f': Benton2004.computation
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.exec_equiv",
"Benton2004.RHL.interp"
] | [] | false | false | false | false | true | let exec_equiv (p p': gexp bool) (f f': computation) : GTot Type0 =
| Benton2004.exec_equiv (interp p) (interp p') f f' | false |
Benton2004.RHL.fst | Benton2004.RHL.holds_interp | val holds_interp
(ge: gexp bool)
(s1 s2: heap)
: Lemma
(holds (interp ge) s1 s2 <==> ge s1 s2 == true)
[SMTPat (holds (interp ge) s1 s2)] | val holds_interp
(ge: gexp bool)
(s1 s2: heap)
: Lemma
(holds (interp ge) s1 s2 <==> ge s1 s2 == true)
[SMTPat (holds (interp ge) s1 s2)] | let holds_interp
(ge: gexp bool)
(s1 s2: heap)
: Lemma
(holds (interp ge) s1 s2 <==> ge s1 s2 == true)
[SMTPat (holds (interp ge) s1 s2)]
= holds_equiv (interp ge) s1 s2 | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 48,
"start_col": 0,
"start_line": 42
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"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 |
ge: Benton2004.RHL.gexp Prims.bool ->
s1: FStar.DM4F.Heap.IntStoreFixed.heap ->
s2: FStar.DM4F.Heap.IntStoreFixed.heap
-> FStar.Pervasives.Lemma
(ensures Benton2004.Aux.holds (Benton2004.RHL.interp ge) s1 s2 <==> ge s1 s2 == true)
[SMTPat (Benton2004.Aux.holds (Benton2004.RHL.interp ge) s1 s2... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Benton2004.Aux.holds_equiv",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"Benton2004.Aux.holds",
"Prims.eq2",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.sm... | [] | true | false | true | false | false | let holds_interp (ge: gexp bool) (s1 s2: heap)
: Lemma (holds (interp ge) s1 s2 <==> ge s1 s2 == true) [SMTPat (holds (interp ge) s1 s2)] =
| holds_equiv (interp ge) s1 s2 | false |
Benton2004.RHL.fst | Benton2004.RHL.r_skip | val r_skip
(p: gexp bool)
: Lemma
(exec_equiv p p skip skip)
[SMTPat (exec_equiv p p skip skip)] | val r_skip
(p: gexp bool)
: Lemma
(exec_equiv p p skip skip)
[SMTPat (exec_equiv p p skip skip)] | let r_skip
(p: gexp bool)
: Lemma
(exec_equiv p p skip skip)
[SMTPat (exec_equiv p p skip skip)]
= d_skip (interp p) | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 69,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"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: Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma (ensures Benton2004.RHL.exec_equiv p p Benton2004.skip Benton2004.skip)
[SMTPat (Benton2004.RHL.exec_equiv p p Benton2004.skip Benton2004.skip)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.d_skip",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Benton2004.RHL.exec_equiv",
"Benton2004.skip",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let r_skip (p: gexp bool) : Lemma (exec_equiv p p skip skip) [SMTPat (exec_equiv p p skip skip)] =
| d_skip (interp p) | false |
Benton2004.RHL.fst | Benton2004.RHL.r_if | val r_if
(b b': exp bool)
(c c' d d' : computation)
(p p' : gexp bool)
: Lemma
(requires (
exec_equiv
(r_if_precond_true b b' c c' d d' p p')
p'
c
c' /\
exec_equiv
(r_if_precond_false b b' c c' d d' p p')
p'
d
d'
))
(ensures (
exec_equiv
(r_i... | val r_if
(b b': exp bool)
(c c' d d' : computation)
(p p' : gexp bool)
: Lemma
(requires (
exec_equiv
(r_if_precond_true b b' c c' d d' p p')
p'
c
c' /\
exec_equiv
(r_if_precond_false b b' c c' d d' p p')
p'
d
d'
))
(ensures (
exec_equiv
(r_i... | let r_if
(b b': exp bool)
(c c' d d' : computation)
(p p' : gexp bool)
: Lemma
(requires (
exec_equiv
(r_if_precond_true b b' c c' d d' p p')
p'
c
c' /\
exec_equiv
(r_if_precond_false b b' c c' d d' p p')
p'
d
d'
))
(ensures (
exec_equiv
(r_i... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 212,
"start_col": 0,
"start_line": 186
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
b': Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
d: Benton2004.computation ->
d': Benton2004.computation ->
p: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Benton2004.RHL.holds_r_if_precond",
"Prims.unit",
"Benton2004.RHL.holds_r_if_precond_false",
"Benton2004.RHL.holds_r_if_precond_true",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.RHL.r_if_precond_true",... | [] | true | false | true | false | false | let r_if (b b': exp bool) (c c' d d': computation) (p p': gexp bool)
: Lemma
(requires
(exec_equiv (r_if_precond_true b b' c c' d d' p p') p' c c' /\
exec_equiv (r_if_precond_false b b' c c' d d' p p') p' d d'))
(ensures
(exec_equiv (r_if_precond b b' c c' d d' p p') p' (ifthen... | holds_r_if_precond_true b b' c c' d d' p p';
holds_r_if_precond_false b b' c c' d d' p p';
holds_r_if_precond b b' c c' d d' p p' | false |
Benton2004.RHL.fst | Benton2004.RHL.r_sub | val r_sub
(p1 p2 p1' p2' : gexp bool)
(f f' : computation)
: Lemma
(requires (
exec_equiv p1 p2 f f' /\
included p1' p1 /\
included p2 p2'
))
(ensures (exec_equiv p1' p2' f f'))
[SMTPat (exec_equiv p1' p2' f f'); SMTPat (exec_equiv p1 p2 f f')] | val r_sub
(p1 p2 p1' p2' : gexp bool)
(f f' : computation)
: Lemma
(requires (
exec_equiv p1 p2 f f' /\
included p1' p1 /\
included p2 p2'
))
(ensures (exec_equiv p1' p2' f f'))
[SMTPat (exec_equiv p1' p2' f f'); SMTPat (exec_equiv p1 p2 f f')] | let r_sub
(p1 p2 p1' p2' : gexp bool)
(f f' : computation)
: Lemma
(requires (
exec_equiv p1 p2 f f' /\
included p1' p1 /\
included p2 p2'
))
(ensures (exec_equiv p1' p2' f f'))
[SMTPat (exec_equiv p1' p2' f f'); SMTPat (exec_equiv p1 p2 f f')]
= d_csub (interp p1) (interp p2) (interp p1') (inte... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 262,
"start_col": 0,
"start_line": 251
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p1: Benton2004.RHL.gexp Prims.bool ->
p2: Benton2004.RHL.gexp Prims.bool ->
p1': Benton2004.RHL.gexp Prims.bool ->
p2': Benton2004.RHL.gexp Prims.bool ->
f: Benton2004.computation ->
f': Benton2004.computation
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv p1 p2 f... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.d_csub",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.RHL.included",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil... | [] | true | false | true | false | false | let r_sub (p1 p2 p1' p2': gexp bool) (f f': computation)
: Lemma (requires (exec_equiv p1 p2 f f' /\ included p1' p1 /\ included p2 p2'))
(ensures (exec_equiv p1' p2' f f'))
[SMTPat (exec_equiv p1' p2' f f'); SMTPat (exec_equiv p1 p2 f f')] =
| d_csub (interp p1) (interp p2) (interp p1') (interp p2') f f' | false |
Benton2004.RHL.fst | Benton2004.RHL.holds_interp_flip | val holds_interp_flip (phi: gexp bool) : Lemma
(forall s1 s2 . holds (interp (flip phi)) s1 s2 <==> holds (Benton2004.flip (interp phi)) s1 s2)
[SMTPat (holds (interp (flip phi)))] | val holds_interp_flip (phi: gexp bool) : Lemma
(forall s1 s2 . holds (interp (flip phi)) s1 s2 <==> holds (Benton2004.flip (interp phi)) s1 s2)
[SMTPat (holds (interp (flip phi)))] | let holds_interp_flip (phi: gexp bool) : Lemma
(forall s1 s2 . holds (interp (flip phi)) s1 s2 <==> holds (Benton2004.flip (interp phi)) s1 s2)
[SMTPat (holds (interp (flip phi)))]
= Benton2004.holds_flip (interp phi) | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 333,
"start_col": 0,
"start_line": 330
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | phi: Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(ensures
forall (s1: FStar.DM4F.Heap.IntStoreFixed.heap) (s2: FStar.DM4F.Heap.IntStoreFixed.heap).
Benton2004.Aux.holds (Benton2004.RHL.interp (Benton2004.RHL.flip phi)) s1 s2 <==>
Benton2004.Aux.holds (Benton2004.flip (Be... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.holds_flip",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_Forall",
"Prims.l_iff",
"Benton2004.Aux.holds",
"Benton2004.RHL.flip",
"Benton2004.flip",
"Prims.Cons",
"FSt... | [] | true | false | true | false | false | let holds_interp_flip (phi: gexp bool)
: Lemma
(forall s1 s2. holds (interp (flip phi)) s1 s2 <==> holds (Benton2004.flip (interp phi)) s1 s2
) [SMTPat (holds (interp (flip phi)))] =
| Benton2004.holds_flip (interp phi) | false |
Benton2004.RHL.fst | Benton2004.RHL.included_alt | val included_alt (p1 p2 : gexp bool) : Lemma
(included p1 p2 <==> (forall s1 s2 . p1 s1 s2 == true ==> p2 s1 s2 == true))
[SMTPat (included p1 p2)] | val included_alt (p1 p2 : gexp bool) : Lemma
(included p1 p2 <==> (forall s1 s2 . p1 s1 s2 == true ==> p2 s1 s2 == true))
[SMTPat (included p1 p2)] | let included_alt (p1 p2 : gexp bool) : Lemma
(included p1 p2 <==> (forall s1 s2 . p1 s1 s2 == true ==> p2 s1 s2 == true))
[SMTPat (included p1 p2)]
= assert (forall s1 s2 . holds (interp p1) s1 s2 <==> p1 s1 s2 == true);
assert (forall s1 s2 . holds (interp p2) s1 s2 <==> p2 s1 s2 == true) | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 249,
"start_col": 0,
"start_line": 245
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p1: Benton2004.RHL.gexp Prims.bool -> p2: Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(ensures
Benton2004.RHL.included p1 p2 <==>
(forall (s1: FStar.DM4F.Heap.IntStoreFixed.heap) (s2: FStar.DM4F.Heap.IntStoreFixed.heap).
p1 s1 s2 == true ==> p2 s1 s2 == true)) [SMTPat (B... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Prims._assert",
"Prims.l_Forall",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.l_iff",
"Benton2004.Aux.holds",
"Benton2004.RHL.interp",
"Prims.eq2",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Benton2004.RHL.included",
"Prims.l_imp",
"Prims.Cons",... | [] | false | false | true | false | false | let included_alt (p1 p2: gexp bool)
: Lemma (included p1 p2 <==> (forall s1 s2. p1 s1 s2 == true ==> p2 s1 s2 == true))
[SMTPat (included p1 p2)] =
| assert (forall s1 s2. holds (interp p1) s1 s2 <==> p1 s1 s2 == true);
assert (forall s1 s2. holds (interp p2) s1 s2 <==> p2 s1 s2 == true) | false |
Steel.Channel.Simplex.fst | Steel.Channel.Simplex.send | val send (#p:prot) (c:chan p) (#next:prot{more next}) (x:msg_t next)
: SteelT unit (sender c next) (fun _ -> sender c (step next x)) | val send (#p:prot) (c:chan p) (#next:prot{more next}) (x:msg_t next)
: SteelT unit (sender c next) (fun _ -> sender c (step next x)) | let rec send (#p:prot) (c:chan p) (#next:prot{more next}) (x:msg_t next)
: SteelT unit (sender c next) (fun _ -> sender c (step next x))
= let v = send_receive_prelude c in //matching v as vs,vr fails
if (fst v).chan_ctr = (snd v).chan_ctr
then (
rewrite_slprop (chan_inv_cond (fst v) (snd v))
... | {
"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": 388,
"start_col": 0,
"start_line": 371
} | (*
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 -> x: Steel.Channel.Protocol.msg_t next
-> Steel.Effect.SteelT Prims.unit | Steel.Effect.SteelT | [] | [] | [
"Steel.Channel.Simplex.prot",
"Steel.Channel.Simplex.chan",
"Prims.b2t",
"Steel.Channel.Protocol.more",
"Steel.Channel.Protocol.msg_t",
"Prims.op_Equality",
"Prims.nat",
"Steel.Channel.Simplex.__proj__Mkchan_val__item__chan_ctr",
"FStar.Pervasives.Native.fst",
"Steel.Channel.Simplex.chan_val",
"... | [
"recursion"
] | false | true | false | false | false | let rec send (#p: prot) (c: chan p) (#next: prot{more next}) (x: msg_t next)
: SteelT unit (sender c next) (fun _ -> sender 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 _ -> ());
send_available c x (fst v) (snd v) ())
else
(rewrite_slprop (chan_inv_cond (fst v) (snd v)) (chan_inv_step (snd v) (fst v)) (fun _ -> ());
intr... | false |
Benton2004.RHL.fst | Benton2004.RHL.exec_equiv_flip | val exec_equiv_flip
(p p': gexp bool)
(f f' : computation)
: Lemma
(exec_equiv (flip p) (flip p') f f' <==> exec_equiv p p' f' f)
[SMTPat (exec_equiv (flip p) (flip p') f f')] | val exec_equiv_flip
(p p': gexp bool)
(f f' : computation)
: Lemma
(exec_equiv (flip p) (flip p') f f' <==> exec_equiv p p' f' f)
[SMTPat (exec_equiv (flip p) (flip p') f f')] | let exec_equiv_flip
(p p': gexp bool)
(f f' : computation)
: Lemma
(exec_equiv (flip p) (flip p') f f' <==> exec_equiv p p' f' f)
[SMTPat (exec_equiv (flip p) (flip p') f f')]
= holds_interp_flip p;
holds_interp_flip p';
exec_equiv_flip (interp p) (interp p') f f' | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 343,
"start_col": 0,
"start_line": 335
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool ->
f: Benton2004.computation ->
f': Benton2004.computation
-> FStar.Pervasives.Lemma
(ensures
Benton2004.RHL.exec_equiv (Benton2004.RHL.flip p) (Benton2004.RHL.flip p') f f' <==>
Benton2004.RHL.exec_equiv p ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.exec_equiv_flip",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.holds_interp_flip",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"Benton2004.RHL.exec_equiv",
"Benton2004.RHL.flip",
"Prims.Cons",
"FStar.Pe... | [] | true | false | true | false | false | let exec_equiv_flip (p p': gexp bool) (f f': computation)
: Lemma (exec_equiv (flip p) (flip p') f f' <==> exec_equiv p p' f' f)
[SMTPat (exec_equiv (flip p) (flip p') f f')] =
| holds_interp_flip p;
holds_interp_flip p';
exec_equiv_flip (interp p) (interp p') f f' | false |
Benton2004.RHL.fst | Benton2004.RHL.r_seq | val r_seq
(p0 p1 p2 : gexp bool)
(c01 c01' c12 c12' : computation)
: Lemma
(requires (
exec_equiv p0 p1 c01 c01' /\
exec_equiv p1 p2 c12 c12'
))
(ensures (
exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')
))
[SMTPatOr [
[SMTPat (exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')); SMTPat (exec_e... | val r_seq
(p0 p1 p2 : gexp bool)
(c01 c01' c12 c12' : computation)
: Lemma
(requires (
exec_equiv p0 p1 c01 c01' /\
exec_equiv p1 p2 c12 c12'
))
(ensures (
exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')
))
[SMTPatOr [
[SMTPat (exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')); SMTPat (exec_e... | let r_seq
(p0 p1 p2 : gexp bool)
(c01 c01' c12 c12' : computation)
: Lemma
(requires (
exec_equiv p0 p1 c01 c01' /\
exec_equiv p1 p2 c12 c12'
))
(ensures (
exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')
))
[SMTPatOr [
[SMTPat (exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')); SMTPat (exec_e... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 61,
"end_line": 230,
"start_col": 0,
"start_line": 214
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p0: Benton2004.RHL.gexp Prims.bool ->
p1: Benton2004.RHL.gexp Prims.bool ->
p2: Benton2004.RHL.gexp Prims.bool ->
c01: Benton2004.computation ->
c01': Benton2004.computation ->
c12: Benton2004.computation ->
c12': Benton2004.computation
-> FStar.Pervasives.Lemma
(requires Benton2004... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.d_seq",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Prims.squash",
"Benton2004.seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"... | [] | true | false | true | false | false | let r_seq (p0 p1 p2: gexp bool) (c01 c01' c12 c12': computation)
: Lemma (requires (exec_equiv p0 p1 c01 c01' /\ exec_equiv p1 p2 c12 c12'))
(ensures (exec_equiv p0 p2 (seq c01 c12) (seq c01' c12')))
[
SMTPatOr
[
[
SMTPat (exec_equiv p0 p2 (seq c01 c12) (seq c01' c1... | d_seq (interp p0) (interp p1) (interp p2) c01 c01' c12 c12' | false |
Benton2004.RHL.fst | Benton2004.RHL.r_while_terminates | val r_while_terminates
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_gexp b Left) (ex... | val r_while_terminates
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_gexp b Left) (ex... | let r_while_terminates
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_gexp b Left) (ex... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 127,
"end_line": 363,
"start_col": 0,
"start_line": 345
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
b': Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
p: Benton2004.RHL.gexp Prims.bool ->
s0: FStar.DM4F.Heap.IntStoreFixed.heap ->
s0': FStar.DM4F.Heap.IntStoreFixed.heap
-> FStar.Pervasives.Lemma
(requires
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.l_imp",
"Prims.l_and",
"Benton2004.RHL.included",
"Benton2004.RHL.flip",
"Benton2004.RHL.geq",
"Benton2004.RHL.exp_to_gex... | [] | false | false | true | false | false | let r_while_terminates (b b': exp bool) (c c': computation) (p: gexp bool) (s0 s0': heap)
: Lemma
(requires
(exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)))
(gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)))
c
c' /\ holds (interp (gand... | let phi = gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) in
let phi_c = gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)) in
let phi_c' = gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) in
Classical.forall_intro (Classical.move_requires (r_while_terminates' b
b'
c
... | false |
Benton2004.RHL.fst | Benton2004.RHL.is_per_gand | val is_per_gand
(e1 e2 : gexp bool)
: Lemma
(requires (is_per e1 /\ is_per e2))
(ensures (is_per (gand e1 e2))) | val is_per_gand
(e1 e2 : gexp bool)
: Lemma
(requires (is_per e1 /\ is_per e2))
(ensures (is_per (gand e1 e2))) | let is_per_gand
(e1 e2 : gexp bool)
: Lemma
(requires (is_per e1 /\ is_per e2))
(ensures (is_per (gand e1 e2)))
= assert (forall s1 s2 .{:pattern (interp (gand e1 e2) s1 s2)} holds (interp (gand e1 e2)) s1 s2 <==> holds (interp e1) s1 s2 /\ holds (interp e2) s1 s2) | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 153,
"end_line": 442,
"start_col": 0,
"start_line": 437
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | e1: Benton2004.RHL.gexp Prims.bool -> e2: Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma (requires Benton2004.RHL.is_per e1 /\ Benton2004.RHL.is_per e2)
(ensures Benton2004.RHL.is_per (Benton2004.RHL.gand e1 e2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Prims._assert",
"Prims.l_Forall",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.l_iff",
"Benton2004.Aux.holds",
"Benton2004.RHL.interp",
"Benton2004.RHL.gand",
"Prims.l_and",
"Prims.unit",
"Benton2004.RHL.is_per",
"Prims.squash",
"Prims.Nil",
"FStar.P... | [] | false | false | true | false | false | let is_per_gand (e1 e2: gexp bool)
: Lemma (requires (is_per e1 /\ is_per e2)) (ensures (is_per (gand e1 e2))) =
| assert (forall s1 s2. {:pattern (interp (gand e1 e2) s1 s2)}
holds (interp (gand e1 e2)) s1 s2 <==> holds (interp e1) s1 s2 /\ holds (interp e2) s1 s2) | false |
Benton2004.RHL.fst | Benton2004.RHL.r_sym | val r_sym
(p p': gexp bool)
(f f' : computation)
: Lemma
(requires (is_per p /\ is_per p'))
(ensures (exec_equiv p p' f f' <==> exec_equiv p p' f' f))
[SMTPat (exec_equiv p p' f f'); SMTPat (is_per p); SMTPat (is_per p')] | val r_sym
(p p': gexp bool)
(f f' : computation)
: Lemma
(requires (is_per p /\ is_per p'))
(ensures (exec_equiv p p' f f' <==> exec_equiv p p' f' f))
[SMTPat (exec_equiv p p' f f'); SMTPat (is_per p); SMTPat (is_per p')] | let r_sym
(p p': gexp bool)
(f f' : computation)
: Lemma
(requires (is_per p /\ is_per p'))
(ensures (exec_equiv p p' f f' <==> exec_equiv p p' f' f))
[SMTPat (exec_equiv p p' f f'); SMTPat (is_per p); SMTPat (is_per p')]
= exec_equiv_sym (interp p) (interp p') f f' | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 460,
"start_col": 0,
"start_line": 453
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool ->
f: Benton2004.computation ->
f': Benton2004.computation
-> FStar.Pervasives.Lemma (requires Benton2004.RHL.is_per p /\ Benton2004.RHL.is_per p')
(ensures Benton2004.RHL.exec_equiv p p' f f' <==> Benton2004.RHL.exec_equiv... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.exec_equiv_sym",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.is_per",
"Prims.squash",
"Prims.l_iff",
"Benton2004.RHL.exec_equiv",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives... | [] | true | false | true | false | false | let r_sym (p p': gexp bool) (f f': computation)
: Lemma (requires (is_per p /\ is_per p'))
(ensures (exec_equiv p p' f f' <==> exec_equiv p p' f' f))
[SMTPat (exec_equiv p p' f f'); SMTPat (is_per p); SMTPat (is_per p')] =
| exec_equiv_sym (interp p) (interp p') f f' | false |
Benton2004.RHL.fst | Benton2004.RHL.r_while | val r_while
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c'
))
(ensures (
exec_equiv (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Righ... | val r_while
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c'
))
(ensures (
exec_equiv (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Righ... | let rec r_while
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c'
))
(ensures (
exec_equiv (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' ... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 420,
"start_col": 0,
"start_line": 393
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
b': Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
p: Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv (Benton2004.RHL.gand p
(Benton2004.RHL.gand (Bent... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"FStar.Classical.forall_intro_3",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.nat",
"Prims.l_imp",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.RHL.gand",
"Benton2004.RHL.exp_to_gexp",
"Benton2004.RH... | [
"recursion"
] | false | false | true | false | false | let rec r_while (b b': exp bool) (c c': computation) (p: gexp bool)
: Lemma
(requires
(exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)))
(gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)))
c
c'))
(ensures
(exec_equiv (gand p... | let g (s0 s0': heap)
: Lemma
((exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)))
(gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)))
c
c' /\ holds (interp (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)))) s0 s0') ==>
(terminates_on (reify... | false |
Benton2004.RHL.fst | Benton2004.RHL.r_while_correct | val r_while_correct
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_gexp ... | val r_while_correct
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_gexp ... | let rec r_while_correct
(b b' : exp bool)
(c c' : computation)
(p: gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) (gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right))) c c' /\
holds (interp (gand p (geq (exp_to_g... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 391,
"start_col": 0,
"start_line": 365
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
b': Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
p: Benton2004.RHL.gexp Prims.bool ->
s0: FStar.DM4F.Heap.IntStoreFixed.heap ->
s0': FStar.DM4F.Heap.IntStoreFixed.heap ->
fuel: Prims.nat
-> FStar.Pervasives.Lem... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.nat",
"FStar.Pervasives.Native.fst",
"Benton2004.reify_exp",
"Benton2004.RHL.r_while_correct",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.snd",
"Prims.unit",
"B... | [
"recursion"
] | false | false | true | false | false | let rec r_while_correct
(b b': exp bool)
(c c': computation)
(p: gexp bool)
(s0 s0': heap)
(fuel: nat)
: Lemma
(requires
(exec_equiv (gand p (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)))
(gand p (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)))
... | let f = reify_computation (while b c) in
let f' = reify_computation (while b' c') in
let fc = reify_computation c in
let fc' = reify_computation c' in
if fst (reify_exp b s0)
then
let s1 = snd (fc fuel s0) in
let s1' = snd (fc' fuel s0') in
r_while_correct b b' c c' p s1 s1' (fuel - 1) | false |
Benton2004.RHL.fst | Benton2004.RHL.d_su1 | val d_su1
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq skip c) c))
[SMTPat (exec_equiv phi phi' (seq skip c) c)] | val d_su1
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq skip c) c))
[SMTPat (exec_equiv phi phi' (seq skip c) c)] | let d_su1
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq skip c) c))
[SMTPat (exec_equiv phi phi' (seq skip c) c)]
= Benton2004.d_su1 c (interp phi) (interp phi') | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 520,
"start_col": 0,
"start_line": 513
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma (requires Benton2004.RHL.exec_equiv phi phi' c c)
(ensures Benton2004.RHL.exec_equiv phi phi' (Benton2004.seq Benton2004.skip c) c)
[SMTPat (Benton2004.RHL.exec_e... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.d_su1",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.exec_equiv",
"Prims.squash",
"Benton2004.seq",
"Benton2004.skip",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let d_su1 (c: computation) (phi phi': gexp bool)
: Lemma (requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq skip c) c))
[SMTPat (exec_equiv phi phi' (seq skip c) c)] =
| Benton2004.d_su1 c (interp phi) (interp phi') | false |
Benton2004.RHL.fst | Benton2004.RHL.d_su2 | val d_su2
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq c skip) c))
[SMTPat (exec_equiv phi phi' (seq c skip) c)] | val d_su2
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq c skip) c))
[SMTPat (exec_equiv phi phi' (seq c skip) c)] | let d_su2
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq c skip) c))
[SMTPat (exec_equiv phi phi' (seq c skip) c)]
= Benton2004.d_su2 c (interp phi) (interp phi') | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 545,
"start_col": 0,
"start_line": 538
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma (requires Benton2004.RHL.exec_equiv phi phi' c c)
(ensures Benton2004.RHL.exec_equiv phi phi' (Benton2004.seq c Benton2004.skip) c)
[SMTPat (Benton2004.RHL.exec_e... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.d_su2",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.exec_equiv",
"Prims.squash",
"Benton2004.seq",
"Benton2004.skip",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let d_su2 (c: computation) (phi phi': gexp bool)
: Lemma (requires (exec_equiv phi phi' c c))
(ensures (exec_equiv phi phi' (seq c skip) c))
[SMTPat (exec_equiv phi phi' (seq c skip) c)] =
| Benton2004.d_su2 c (interp phi) (interp phi') | false |
Benton2004.RHL.fst | Benton2004.RHL.r_trans | val r_trans
(p p' : gexp bool)
(c1 c2 c3 : computation)
: Lemma
(requires (
is_per p' /\
interpolable p /\
exec_equiv p p' c1 c2 /\
exec_equiv p p' c2 c3
))
(ensures (exec_equiv p p' c1 c3))
[SMTPatOr [
[SMTPat (exec_equiv p p' c1 c2); SMTPat (exec_equiv p p' c2 c3); SMTPat (is_per p'); ... | val r_trans
(p p' : gexp bool)
(c1 c2 c3 : computation)
: Lemma
(requires (
is_per p' /\
interpolable p /\
exec_equiv p p' c1 c2 /\
exec_equiv p p' c2 c3
))
(ensures (exec_equiv p p' c1 c3))
[SMTPatOr [
[SMTPat (exec_equiv p p' c1 c2); SMTPat (exec_equiv p p' c2 c3); SMTPat (is_per p'); ... | let r_trans
(p p' : gexp bool)
(c1 c2 c3 : computation)
: Lemma
(requires (
is_per p' /\
interpolable p /\
exec_equiv p p' c1 c2 /\
exec_equiv p p' c2 c3
))
(ensures (exec_equiv p p' c1 c3))
[SMTPatOr [
[SMTPat (exec_equiv p p' c1 c2); SMTPat (exec_equiv p p' c2 c3); SMTPat (is_per p'); ... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 50,
"end_line": 509,
"start_col": 0,
"start_line": 493
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
p: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool ->
c1: Benton2004.computation ->
c2: Benton2004.computation ->
c3: Benton2004.computation
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.is_per p' /\ Benton2004.RHL.interpolable p /\
Benton2004.RHL.e... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.exec_equiv_trans",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.is_per",
"Benton2004.RHL.interpolable",
"Benton2004.RHL.exec_equiv",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
... | [] | true | false | true | false | false | let r_trans (p p': gexp bool) (c1 c2 c3: computation)
: Lemma
(requires (is_per p' /\ interpolable p /\ exec_equiv p p' c1 c2 /\ exec_equiv p p' c2 c3))
(ensures (exec_equiv p p' c1 c3))
[
SMTPatOr
[
[
SMTPat (exec_equiv p p' c1 c2);
SMTPat (exec_e... | exec_equiv_trans (interp p) (interp p') c1 c2 c3 | false |
Benton2004.RHL.fst | Benton2004.RHL.d_su1' | val d_su1'
(c c' c'' : computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' c skip /\
exec_equiv phi' phi'' c' c''
))
(ensures (exec_equiv phi phi'' (seq c c') c''))
[SMTPatOr [
[SMTPat (exec_equiv phi phi'' (seq c c') c''); SMTPat (exec_equiv phi phi' c skip)];
... | val d_su1'
(c c' c'' : computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' c skip /\
exec_equiv phi' phi'' c' c''
))
(ensures (exec_equiv phi phi'' (seq c c') c''))
[SMTPatOr [
[SMTPat (exec_equiv phi phi'' (seq c c') c''); SMTPat (exec_equiv phi phi' c skip)];
... | let d_su1'
(c c' c'' : computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' c skip /\
exec_equiv phi' phi'' c' c''
))
(ensures (exec_equiv phi phi'' (seq c c') c''))
[SMTPatOr [
[SMTPat (exec_equiv phi phi'' (seq c c') c''); SMTPat (exec_equiv phi phi' c skip)];
... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 536,
"start_col": 0,
"start_line": 522
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c: Benton2004.computation ->
c': Benton2004.computation ->
c'': Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool ->
phi'': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv phi phi' c... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.d_su1'",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.skip",
"Prims.squash",
"Benton2004.seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or... | [] | true | false | true | false | false | let d_su1' (c c' c'': computation) (phi phi' phi'': gexp bool)
: Lemma (requires (exec_equiv phi phi' c skip /\ exec_equiv phi' phi'' c' c''))
(ensures (exec_equiv phi phi'' (seq c c') c''))
[
SMTPatOr
[
[SMTPat (exec_equiv phi phi'' (seq c c') c''); SMTPat (exec_equiv phi phi'... | Benton2004.d_su1' c c' c'' (interp phi) (interp phi') (interp phi'') | false |
Benton2004.RHL.fst | Benton2004.RHL.d_lu1 | val d_lu1
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (ifthenelse b (seq c (while b c)) skip))) | val d_lu1
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (ifthenelse b (seq c (while b c)) skip))) | let d_lu1
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (ifthenelse b (seq c (while b c)) skip)))
= Benton2004.d_lu1 b c (interp phi) (interp phi') | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 582,
"start_col": 0,
"start_line": 575
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires Benton2004.RHL.exec_equiv phi phi' (Benton2004.while b c) (Benton2004.while b c))
(ensures
Benton2004.RHL.ex... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Benton2004.d_lu1",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.exec_equiv",
"Benton2004.while",
"Prims.squash",
"Benton2004.ifthenelse",
"Benton2004.seq",
"Benton2004.skip",
"Prims.Nil",
"FStar.P... | [] | true | false | true | false | false | let d_lu1 (b: exp bool) (c: computation) (phi phi': gexp bool)
: Lemma (requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (ifthenelse b (seq c (while b c)) skip))) =
| Benton2004.d_lu1 b c (interp phi) (interp phi') | false |
Benton2004.RHL.fst | Benton2004.RHL.d_cc | val d_cc
(b: exp bool)
(c1 c2 c3: computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' (ifthenelse b c1 c2) (ifthenelse b c1 c2) /\
exec_equiv phi' phi'' c3 c3
))
(ensures (
exec_equiv phi phi'' (seq (ifthenelse b c1 c2) c3) (ifthenelse b (seq c1 c3) (seq c2 c3))
)... | val d_cc
(b: exp bool)
(c1 c2 c3: computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' (ifthenelse b c1 c2) (ifthenelse b c1 c2) /\
exec_equiv phi' phi'' c3 c3
))
(ensures (
exec_equiv phi phi'' (seq (ifthenelse b c1 c2) c3) (ifthenelse b (seq c1 c3) (seq c2 c3))
)... | let d_cc
(b: exp bool)
(c1 c2 c3: computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' (ifthenelse b c1 c2) (ifthenelse b c1 c2) /\
exec_equiv phi' phi'' c3 c3
))
(ensures (
exec_equiv phi phi'' (seq (ifthenelse b c1 c2) c3) (ifthenelse b (seq c1 c3) (seq c2 c3))
)... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 573,
"start_col": 0,
"start_line": 556
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
c1: Benton2004.computation ->
c2: Benton2004.computation ->
c3: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool ->
phi'': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Benton2004.d_cc",
"Benton2004.RHL.interp",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.ifthenelse",
"Prims.squash",
"Benton2004.seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FSt... | [] | true | false | true | false | false | let d_cc (b: exp bool) (c1 c2 c3: computation) (phi phi' phi'': gexp bool)
: Lemma
(requires
(exec_equiv phi phi' (ifthenelse b c1 c2) (ifthenelse b c1 c2) /\
exec_equiv phi' phi'' c3 c3))
(ensures
(exec_equiv phi phi'' (seq (ifthenelse b c1 c2) c3) (ifthenelse b (seq c1 c3) (s... | Benton2004.d_cc b c1 c2 c3 (interp phi) (interp phi') (interp phi'') | false |
Benton2004.RHL.fst | Benton2004.RHL.d_assoc | val d_assoc
(c1 c2 c3: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq (seq c1 c2) c3)))
(ensures (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3))))
[SMTPat (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3)))] | val d_assoc
(c1 c2 c3: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq (seq c1 c2) c3)))
(ensures (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3))))
[SMTPat (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3)))] | let d_assoc
(c1 c2 c3: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq (seq c1 c2) c3)))
(ensures (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3))))
[SMTPat (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3)))]
= Benton2004.d_assoc ... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 56,
"end_line": 554,
"start_col": 0,
"start_line": 547
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c1: Benton2004.computation ->
c2: Benton2004.computation ->
c3: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv phi
phi'
(Benton2004.seq (Benton200... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.d_assoc",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.exec_equiv",
"Benton2004.seq",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let d_assoc (c1 c2 c3: computation) (phi phi': gexp bool)
: Lemma (requires (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq (seq c1 c2) c3)))
(ensures (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3))))
[SMTPat (exec_equiv phi phi' (seq (seq c1 c2) c3) (seq c1 (seq c2 c3)))] =
| Benton2004.d_assoc c1 c2 c3 (interp phi) (interp phi') | false |
Benton2004.RHL.fst | Benton2004.RHL.d_lu2 | val d_lu2
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (while b (seq c (ifthenelse b c skip))))) | val d_lu2
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (while b (seq c (ifthenelse b c skip))))) | let d_lu2
(b: exp bool)
(c: computation)
(phi phi' : gexp bool)
: Lemma
(requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (while b (seq c (ifthenelse b c skip)))))
= Benton2004.d_lu2 b c (interp phi) (interp phi') | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 49,
"end_line": 591,
"start_col": 0,
"start_line": 584
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires Benton2004.RHL.exec_equiv phi phi' (Benton2004.while b c) (Benton2004.while b c))
(ensures
Benton2004.RHL.ex... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Benton2004.d_lu2",
"Benton2004.RHL.interp",
"Prims.unit",
"Benton2004.RHL.exec_equiv",
"Benton2004.while",
"Prims.squash",
"Benton2004.seq",
"Benton2004.ifthenelse",
"Benton2004.skip",
"Prims.Nil",
"FStar.P... | [] | true | false | true | false | false | let d_lu2 (b: exp bool) (c: computation) (phi phi': gexp bool)
: Lemma (requires (exec_equiv phi phi' (while b c) (while b c)))
(ensures (exec_equiv phi phi' (while b c) (while b (seq c (ifthenelse b c skip))))) =
| Benton2004.d_lu2 b c (interp phi) (interp phi') | false |
Benton2004.RHL.fst | Benton2004.RHL.r_cbl | val r_cbl
(b: exp bool)
(c c' d : computation)
(phi phi' : gexp bool)
: Lemma
(requires (
exec_equiv
(gand phi (exp_to_gexp b Left))
phi'
c
d /\
exec_equiv
(gand phi (gnot (exp_to_gexp b Left)))
phi'
c'
d
))
(ensures (
exec_equiv
phi
ph... | val r_cbl
(b: exp bool)
(c c' d : computation)
(phi phi' : gexp bool)
: Lemma
(requires (
exec_equiv
(gand phi (exp_to_gexp b Left))
phi'
c
d /\
exec_equiv
(gand phi (gnot (exp_to_gexp b Left)))
phi'
c'
d
))
(ensures (
exec_equiv
phi
ph... | let r_cbl
(b: exp bool)
(c c' d : computation)
(phi phi' : gexp bool)
: Lemma
(requires (
exec_equiv
(gand phi (exp_to_gexp b Left))
phi'
c
d /\
exec_equiv
(gand phi (gnot (exp_to_gexp b Left)))
phi'
c'
d
))
(ensures (
exec_equiv
phi
ph... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 660,
"start_col": 0,
"start_line": 628
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
d: Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv (Benton2004.RHL.gand ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.squash",
"Prims.l_Forall",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.l_iff",
"Benton2004.Aux.holds",
"Benton2004.RHL.interp",
"Benton2004.RHL.gand",
"Benton2004.RHL.gnot",
"Benton2004.RHL.exp_to_gexp",... | [] | false | false | true | false | false | let r_cbl (b: exp bool) (c c' d: computation) (phi phi': gexp bool)
: Lemma
(requires
(exec_equiv (gand phi (exp_to_gexp b Left)) phi' c d /\
exec_equiv (gand phi (gnot (exp_to_gexp b Left))) phi' c' d))
(ensures (exec_equiv phi phi' (ifthenelse b c c') d)) =
| let _:squash (forall s1 s2.
holds (interp (gand phi (exp_to_gexp b Left))) s1 s2 <==>
holds (interp phi) s1 s2 /\ fst (reify_exp b s1) == true) =
assert (forall s1 s2.
holds (interp (gand phi (exp_to_gexp b Left))) s1 s2 <==>
holds (interp phi) s1 s2 /\ fst (reify_exp b s1) == true)
in
let... | false |
Vale.Curve25519.X64.FastUtil.fst | Vale.Curve25519.X64.FastUtil.va_qcode_Fast_mul1 | val va_qcode_Fast_mul1 (va_mods: va_mods_t) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_mul1 ())) | val va_qcode_Fast_mul1 (va_mods: va_mods_t) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_mul1 ())) | let va_qcode_Fast_mul1 (va_mods:va_mods_t) (dst_b:buffer64) (inA_b:buffer64) : (va_quickCode unit
(va_code_Fast_mul1 ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(a0:Vale.Def.Types_s.nat64) = Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s)
in let (a1:... | {
"file_name": "obj/Vale.Curve25519.X64.FastUtil.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 168,
"start_col": 0,
"start_line": 79
} | module Vale.Curve25519.X64.FastUtil
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsStack
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open FStar.Tactics
open Vale.Curve25519.... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsStack.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.FastUtil_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Curve25519.Fast_lemmas_external",
"short_module": nul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_mods: Vale.X64.QuickCode.va_mods_t ->
dst_b: Vale.X64.Memory.buffer64 ->
inA_b: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Curve25519.X64.FastUtil.va_code_Fast_mul1 ()) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.va_mods_t",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCodes.qblock",
"Prims.unit",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.InsMem.va_code_Mem64_lemma",
"Vale.X64.InsBasic.va_code_Mulx64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rR9",
"Vale.X64.M... | [] | false | false | false | false | false | let va_qcode_Fast_mul1 (va_mods: va_mods_t) (dst_b inA_b: buffer64)
: (va_quickCode unit (va_code_Fast_mul1 ())) =
| (qblock va_mods
(fun (va_s: va_state) ->
let va_old_s:va_state = va_s in
let a0:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b 0 (va_get_mem_heaplet 0 va_s)
in
let a1:Vale.Def.Types_s.nat64 =
Vale.X64.Decls.buffer64_read inA_b 1 (va_get_mem_heaplet 0 ... | false |
Benton2004.RHL.fst | Benton2004.RHL.r_while_terminates' | val r_while_terminates'
(b b' : exp bool)
(c c' : computation)
(phi phi_c phi_c': gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
included phi (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) /\
included (gand phi (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) phi_c /\
included ... | val r_while_terminates'
(b b' : exp bool)
(c c' : computation)
(phi phi_c phi_c': gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
included phi (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) /\
included (gand phi (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) phi_c /\
included ... | let rec r_while_terminates'
(b b' : exp bool)
(c c' : computation)
(phi phi_c phi_c': gexp bool)
(s0 s0' : heap)
(fuel: nat)
: Lemma
(requires (
included phi (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) /\
included (gand phi (gand (exp_to_gexp b Left) (exp_to_gexp b' Right))) phi_c /\
inclu... | {
"file_name": "examples/rel/Benton2004.RHL.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 328,
"start_col": 0,
"start_line": 269
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"Benton2004.fst.checked"
],
"interface_file": true,
"source_file": "Benton2004.RHL.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Per... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 2,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
b: Benton2004.exp Prims.bool ->
b': Benton2004.exp Prims.bool ->
c: Benton2004.computation ->
c': Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi_c: Benton2004.RHL.gexp Prims.bool ->
phi_c': Benton2004.RHL.gexp Prims.bool ->
s0: FStar.DM4F.Heap.IntStoreFixed.heap ->... | FStar.Pervasives.Lemma | [
"",
"lemma"
] | [] | [
"Benton2004.exp",
"Prims.bool",
"Benton2004.computation",
"Benton2004.RHL.gexp",
"FStar.DM4F.Heap.IntStoreFixed.heap",
"Prims.nat",
"FStar.Pervasives.Native.fst",
"Benton2004.reify_exp",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"Prims.eq2",
"Benton2004.terminates_on",
"FStar.Classical.... | [
"recursion"
] | false | false | true | false | false | let rec r_while_terminates'
(b b': exp bool)
(c c': computation)
(phi phi_c phi_c': gexp bool)
(s0 s0': heap)
(fuel: nat)
: Lemma
(requires
(included phi (geq (exp_to_gexp b Left) (exp_to_gexp b' Right)) /\
included (gand phi (gand (exp_to_gexp b Left) (exp_to_g... | let f = reify_computation (while b c) in
let f' = reify_computation (while b' c') in
let fc = reify_computation c in
let fc' = reify_computation c' in
if fst (reify_exp b s0)
then
(assert (holds (interp (gand phi (gand (exp_to_gexp b Left) (exp_to_gexp b' Right)))) s0 s0');
assert (terminates_on (fc') s0');
l... | false |
Spec.P256.fst | Spec.P256.point_mul_g | val point_mul_g (a: qelem) : proj_point | val point_mul_g (a: qelem) : proj_point | let point_mul_g (a:qelem) : proj_point = point_mul a base_point | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 63,
"start_col": 0,
"start_line": 63
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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: Spec.P256.PointOps.qelem -> Spec.P256.PointOps.proj_point | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.qelem",
"Spec.P256.point_mul",
"Spec.P256.PointOps.base_point",
"Spec.P256.PointOps.proj_point"
] | [] | false | false | false | true | false | let point_mul_g (a: qelem) : proj_point =
| point_mul a base_point | false |
Spec.P256.fst | Spec.P256.mk_p256_comm_monoid | val mk_p256_comm_monoid:LE.comm_monoid aff_point | val mk_p256_comm_monoid:LE.comm_monoid aff_point | let mk_p256_comm_monoid : LE.comm_monoid aff_point = {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = PL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = PL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = PL.aff_point_add_comm_lemma;
} | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 1,
"end_line": 28,
"start_col": 0,
"start_line": 22
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | Lib.Exponentiation.Definition.comm_monoid Spec.P256.PointOps.aff_point | Prims.Tot | [
"total"
] | [] | [
"Lib.Exponentiation.Definition.Mkcomm_monoid",
"Spec.P256.PointOps.aff_point",
"Spec.P256.PointOps.aff_point_at_inf",
"Spec.P256.PointOps.aff_point_add",
"Spec.P256.Lemmas.aff_point_at_inf_lemma",
"Spec.P256.Lemmas.aff_point_add_assoc_lemma",
"Spec.P256.Lemmas.aff_point_add_comm_lemma"
] | [] | false | false | false | true | false | let mk_p256_comm_monoid:LE.comm_monoid aff_point =
| {
LE.one = aff_point_at_inf;
LE.mul = aff_point_add;
LE.lemma_one = PL.aff_point_at_inf_lemma;
LE.lemma_mul_assoc = PL.aff_point_add_assoc_lemma;
LE.lemma_mul_comm = PL.aff_point_add_comm_lemma
} | false |
Spec.P256.fst | Spec.P256.point_double_c | val point_double_c : SE.sqr_st proj_point mk_to_p256_comm_monoid | val point_double_c : SE.sqr_st proj_point mk_to_p256_comm_monoid | let point_double_c p =
PL.to_aff_point_double_lemma p;
point_double p | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 49,
"start_col": 0,
"start_line": 47
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | Spec.Exponentiation.sqr_st Spec.P256.PointOps.proj_point Spec.P256.mk_to_p256_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.proj_point",
"Spec.P256.PointOps.point_double",
"Prims.unit",
"Spec.P256.Lemmas.to_aff_point_double_lemma"
] | [] | false | false | false | true | false | let point_double_c p =
| PL.to_aff_point_double_lemma p;
point_double p | false |
Spec.P256.fst | Spec.P256.point_mul | val point_mul (a: qelem) (p: proj_point) : proj_point | val point_mul (a: qelem) (p: proj_point) : proj_point | let point_mul (a:qelem) (p:proj_point) : proj_point =
SE.exp_fw mk_p256_concrete_ops p 256 a 4 | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 60,
"start_col": 0,
"start_line": 59
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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: Spec.P256.PointOps.qelem -> p: Spec.P256.PointOps.proj_point -> Spec.P256.PointOps.proj_point | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.qelem",
"Spec.P256.PointOps.proj_point",
"Spec.Exponentiation.exp_fw",
"Spec.P256.mk_p256_concrete_ops"
] | [] | false | false | false | true | false | let point_mul (a: qelem) (p: proj_point) : proj_point =
| SE.exp_fw mk_p256_concrete_ops p 256 a 4 | false |
Spec.P256.fst | Spec.P256.point_add_c | val point_add_c : SE.mul_st proj_point mk_to_p256_comm_monoid | val point_add_c : SE.mul_st proj_point mk_to_p256_comm_monoid | let point_add_c p q =
PL.to_aff_point_add_lemma p q;
point_add p q | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 44,
"start_col": 0,
"start_line": 42
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | Spec.Exponentiation.mul_st Spec.P256.PointOps.proj_point Spec.P256.mk_to_p256_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.proj_point",
"Spec.P256.PointOps.point_add",
"Prims.unit",
"Spec.P256.Lemmas.to_aff_point_add_lemma"
] | [] | false | false | false | true | false | let point_add_c p q =
| PL.to_aff_point_add_lemma p q;
point_add p q | false |
Spec.P256.fst | Spec.P256.point_mul_double_g | val point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point | val point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point | let point_mul_double_g (a1 a2:qelem) (p:proj_point) : proj_point =
SE.exp_double_fw mk_p256_concrete_ops base_point 256 a1 p a2 5 | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 67,
"start_col": 0,
"start_line": 66
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | a1: Spec.P256.PointOps.qelem -> a2: Spec.P256.PointOps.qelem -> p: Spec.P256.PointOps.proj_point
-> Spec.P256.PointOps.proj_point | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.qelem",
"Spec.P256.PointOps.proj_point",
"Spec.Exponentiation.exp_double_fw",
"Spec.P256.mk_p256_concrete_ops",
"Spec.P256.PointOps.base_point"
] | [] | false | false | false | true | false | let point_mul_double_g (a1 a2: qelem) (p: proj_point) : proj_point =
| SE.exp_double_fw mk_p256_concrete_ops base_point 256 a1 p a2 5 | false |
Spec.P256.fst | Spec.P256.point_at_inf_c | val point_at_inf_c: SE.one_st proj_point mk_to_p256_comm_monoid | val point_at_inf_c: SE.one_st proj_point mk_to_p256_comm_monoid | let point_at_inf_c _ =
PL.to_aff_point_at_infinity_lemma ();
point_at_inf | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 39,
"start_col": 0,
"start_line": 37
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | Spec.Exponentiation.one_st Spec.P256.PointOps.proj_point Spec.P256.mk_to_p256_comm_monoid | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Spec.P256.PointOps.point_at_inf",
"Spec.P256.Lemmas.to_aff_point_at_infinity_lemma",
"Spec.P256.PointOps.proj_point"
] | [] | false | false | false | true | false | let point_at_inf_c _ =
| PL.to_aff_point_at_infinity_lemma ();
point_at_inf | false |
Spec.P256.fst | Spec.P256.min_input_length | val min_input_length (a: hash_alg_ecdsa) : nat | val min_input_length (a: hash_alg_ecdsa) : nat | let min_input_length (a:hash_alg_ecdsa) : nat =
match a with | NoHash -> 32 | Hash a -> 0 | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 84,
"start_col": 0,
"start_line": 83
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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: Spec.P256.hash_alg_ecdsa -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.hash_alg_ecdsa",
"Spec.Hash.Definitions.hash_alg",
"Prims.l_or",
"Prims.eq2",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Hash.Definitions.SHA2_384",
"Spec.Hash.Definitions.SHA2_512",
"Prims.nat"
] | [] | false | false | false | true | false | let min_input_length (a: hash_alg_ecdsa) : nat =
| match a with
| NoHash -> 32
| Hash a -> 0 | false |
Spec.P256.fst | Spec.P256.hash_ecdsa | val hash_ecdsa:
a:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length a}
-> msg:lseq uint8 msg_len ->
Tot (r:lbytes
(if Hash? a then hash_length (match a with Hash a -> a) else msg_len){length r >= 32}) | val hash_ecdsa:
a:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length a}
-> msg:lseq uint8 msg_len ->
Tot (r:lbytes
(if Hash? a then hash_length (match a with Hash a -> a) else msg_len){length r >= 32}) | let hash_ecdsa a msg_len msg =
match a with | NoHash -> msg | Hash a -> Spec.Agile.Hash.hash a msg | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 95,
"start_col": 0,
"start_line": 94
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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: Spec.P256.hash_alg_ecdsa ->
msg_len: Lib.IntTypes.size_nat{msg_len >= Spec.P256.min_input_length a} ->
msg: Lib.Sequence.lseq Lib.IntTypes.uint8 msg_len
-> r:
Lib.ByteSequence.lbytes (match Hash? a with
| true ->
Spec.Hash.Definitions.hash_length (let Spec.P256.Hash a = a in
... | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.hash_alg_ecdsa",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Spec.P256.min_input_length",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.Hash.Definitions.hash_alg",
"Prims.l_or",
"Prims.eq2",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Hash.Definitions.SHA2_3... | [] | false | false | false | false | false | let hash_ecdsa a msg_len msg =
| match a with
| NoHash -> msg
| Hash a -> Spec.Agile.Hash.hash a msg | false |
Spec.P256.fst | Spec.P256.ecdsa_verify_msg_as_qelem | val ecdsa_verify_msg_as_qelem (m: qelem) (public_key: lbytes 64) (sign_r sign_s: lbytes 32) : bool | val ecdsa_verify_msg_as_qelem (m: qelem) (public_key: lbytes 64) (sign_r sign_s: lbytes 32) : bool | let ecdsa_verify_msg_as_qelem (m:qelem) (public_key:lbytes 64) (sign_r sign_s:lbytes 32) : bool =
let pk = load_point public_key in
let r = nat_from_bytes_be sign_r in
let s = nat_from_bytes_be sign_s in
let is_r_valid = 0 < r && r < order in
let is_s_valid = 0 < s && s < order in
if not (Some? pk && is_r_... | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 134,
"start_col": 0,
"start_line": 117
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: Spec.P256.PointOps.qelem ->
public_key: Lib.ByteSequence.lbytes 64 ->
sign_r: Lib.ByteSequence.lbytes 32 ->
sign_s: Lib.ByteSequence.lbytes 32
-> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.qelem",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.P256.PointOps.proj_point",
"Prims.bool",
"Prims.nat",
"Spec.P256.PointOps.is_point_at_inf",
"FStar.Pervasives.Native.Mktuple3",
"Prims.op_Equality",
"Pri... | [] | false | false | false | false | false | let ecdsa_verify_msg_as_qelem (m: qelem) (public_key: lbytes 64) (sign_r sign_s: lbytes 32) : bool =
| let pk = load_point public_key in
let r = nat_from_bytes_be sign_r in
let s = nat_from_bytes_be sign_s in
let is_r_valid = 0 < r && r < order in
let is_s_valid = 0 < s && s < order in
if not (Some? pk && is_r_valid && is_s_valid)
then false
else
let sinv = qinv s in
let u1 = sinv *^ m in
let u2 = sinv *^ r in
l... | false |
Spec.P256.fst | Spec.P256.ecdsa_sign_msg_as_qelem | val ecdsa_sign_msg_as_qelem (m: qelem) (private_key nonce: lbytes 32) : option (lbytes 64) | val ecdsa_sign_msg_as_qelem (m: qelem) (private_key nonce: lbytes 32) : option (lbytes 64) | let ecdsa_sign_msg_as_qelem (m:qelem) (private_key nonce:lbytes 32) : option (lbytes 64) =
let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let is_privkey_valid = 0 < d_a && d_a < order in
let is_nonce_valid = 0 < k_q && k_q < order in
if not (is_privkey_valid && is_nonce_valid... | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 114,
"start_col": 0,
"start_line": 98
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: Spec.P256.PointOps.qelem ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.PointOps.qelem",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.None",
"Prims.bool",
"Prims.nat",
"Prims.op_BarBar",
"Prims.op_Equality",
"Prims.int",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.... | [] | false | false | false | false | false | let ecdsa_sign_msg_as_qelem (m: qelem) (private_key nonce: lbytes 32) : option (lbytes 64) =
| let k_q = nat_from_bytes_be nonce in
let d_a = nat_from_bytes_be private_key in
let is_privkey_valid = 0 < d_a && d_a < order in
let is_nonce_valid = 0 < k_q && k_q < order in
if not (is_privkey_valid && is_nonce_valid)
then None
else
let _X, _Y, _Z = point_mul_g k_q in
let x = _X /% _Z in
let r = x % order in
... | false |
Spec.P256.fst | Spec.P256.validate_public_key | val validate_public_key (pk: lbytes 64) : bool | val validate_public_key (pk: lbytes 64) : bool | let validate_public_key (pk:lbytes 64) : bool =
Some? (load_point pk) | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 202,
"start_col": 0,
"start_line": 201
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | pk: Lib.ByteSequence.lbytes 64 -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.P256.PointOps.proj_point",
"Spec.P256.PointOps.load_point",
"Prims.bool"
] | [] | false | false | false | false | false | let validate_public_key (pk: lbytes 64) : bool =
| Some? (load_point pk) | false |
Spec.P256.fst | Spec.P256.ecdsa_verification_agile | val ecdsa_verification_agile:
alg:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length alg}
-> msg:lbytes msg_len
-> public_key:lbytes 64
-> signature_r:lbytes 32
-> signature_s:lbytes 32 ->
bool | val ecdsa_verification_agile:
alg:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length alg}
-> msg:lbytes msg_len
-> public_key:lbytes 64
-> signature_r:lbytes 32
-> signature_s:lbytes 32 ->
bool | let ecdsa_verification_agile alg msg_len msg public_key signature_r signature_s =
let hashM = hash_ecdsa alg msg_len msg in
let m_q = nat_from_bytes_be (sub hashM 0 32) % order in
ecdsa_verify_msg_as_qelem m_q public_key signature_r signature_s | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 66,
"end_line": 171,
"start_col": 0,
"start_line": 168
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 |
alg: Spec.P256.hash_alg_ecdsa ->
msg_len: Lib.IntTypes.size_nat{msg_len >= Spec.P256.min_input_length alg} ->
msg: Lib.ByteSequence.lbytes msg_len ->
public_key: Lib.ByteSequence.lbytes 64 ->
signature_r: Lib.ByteSequence.lbytes 32 ->
signature_s: Lib.ByteSequence.lbytes 32
-> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.hash_alg_ecdsa",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Spec.P256.min_input_length",
"Lib.ByteSequence.lbytes",
"Spec.P256.ecdsa_verify_msg_as_qelem",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Lib.Seque... | [] | false | false | false | false | false | let ecdsa_verification_agile alg msg_len msg public_key signature_r signature_s =
| let hashM = hash_ecdsa alg msg_len msg in
let m_q = nat_from_bytes_be (sub hashM 0 32) % order in
ecdsa_verify_msg_as_qelem m_q public_key signature_r signature_s | false |
Spec.P256.fst | Spec.P256.pk_uncompressed_to_raw | val pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64) | val pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64) | let pk_uncompressed_to_raw (pk:lbytes 65) : option (lbytes 64) =
if Lib.RawIntTypes.u8_to_UInt8 pk.[0] <> 0x04uy then None else Some (sub pk 1 64) | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 205,
"start_col": 0,
"start_line": 204
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | pk: Lib.ByteSequence.lbytes 65 -> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"Prims.op_disEquality",
"FStar.UInt8.t",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.UInt8.__uint_to_t",
"FStar.Pervasives.Native.None",
"Prims.bool",
"FStar.Pervasives.Native.So... | [] | false | false | false | false | false | let pk_uncompressed_to_raw (pk: lbytes 65) : option (lbytes 64) =
| if Lib.RawIntTypes.u8_to_UInt8 pk.[ 0 ] <> 0x04uy then None else Some (sub pk 1 64) | false |
Spec.P256.fst | Spec.P256.ecdh | val ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64) | val ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64) | let ecdh (their_public_key:lbytes 64) (private_key:lbytes 32) : option (lbytes 64) =
let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < order in
if Some? pk && is_sk_valid then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
e... | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 192,
"start_col": 0,
"start_line": 185
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | their_public_key: Lib.ByteSequence.lbytes 64 -> private_key: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.P256.PointOps.proj_point",
"FStar.Pervasives.Native.Some",
"Spec.P256.PointOps.point_store",
"Spec.P256.point_mul",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.bool",
"FStar.Pervasives.Native.No... | [] | false | false | false | false | false | let ecdh (their_public_key: lbytes 64) (private_key: lbytes 32) : option (lbytes 64) =
| let pk = load_point their_public_key in
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < order in
if Some? pk && is_sk_valid
then
let ss = point_mul sk (Some?.v pk) in
Some (point_store ss)
else None | false |
Spec.P256.fst | Spec.P256.ecdsa_signature_agile | val ecdsa_signature_agile:
alg:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length alg}
-> msg:lbytes msg_len
-> private_key:lbytes 32
-> nonce:lbytes 32 ->
option (lbytes 64) | val ecdsa_signature_agile:
alg:hash_alg_ecdsa
-> msg_len:size_nat{msg_len >= min_input_length alg}
-> msg:lbytes msg_len
-> private_key:lbytes 32
-> nonce:lbytes 32 ->
option (lbytes 64) | let ecdsa_signature_agile alg msg_len msg private_key nonce =
let hashM = hash_ecdsa alg msg_len msg in
let m_q = nat_from_bytes_be (sub hashM 0 32) % order in
ecdsa_sign_msg_as_qelem m_q private_key nonce | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 156,
"start_col": 0,
"start_line": 153
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 |
alg: Spec.P256.hash_alg_ecdsa ->
msg_len: Lib.IntTypes.size_nat{msg_len >= Spec.P256.min_input_length alg} ->
msg: Lib.ByteSequence.lbytes msg_len ->
private_key: Lib.ByteSequence.lbytes 32 ->
nonce: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Spec.P256.hash_alg_ecdsa",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Spec.P256.min_input_length",
"Lib.ByteSequence.lbytes",
"Spec.P256.ecdsa_sign_msg_as_qelem",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Lib.Sequenc... | [] | false | false | false | false | false | let ecdsa_signature_agile alg msg_len msg private_key nonce =
| let hashM = hash_ecdsa alg msg_len msg in
let m_q = nat_from_bytes_be (sub hashM 0 32) % order in
ecdsa_sign_msg_as_qelem m_q private_key nonce | false |
Spec.P256.fst | Spec.P256.pk_uncompressed_from_raw | val pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65 | val pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65 | let pk_uncompressed_from_raw (pk:lbytes 64) : lbytes 65 =
concat (create 1 (u8 0x04)) pk | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 208,
"start_col": 0,
"start_line": 207
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | pk: Lib.ByteSequence.lbytes 64 -> Lib.ByteSequence.lbytes 65 | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.create",
"Lib.IntTypes.u8"
] | [] | false | false | false | false | false | let pk_uncompressed_from_raw (pk: lbytes 64) : lbytes 65 =
| concat (create 1 (u8 0x04)) pk | false |
Spec.P256.fst | Spec.P256.secret_to_public | val secret_to_public (private_key: lbytes 32) : option (lbytes 64) | val secret_to_public (private_key: lbytes 32) : option (lbytes 64) | let secret_to_public (private_key:lbytes 32) : option (lbytes 64) =
let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < order in
if is_sk_valid then
let pk = point_mul_g sk in
Some (point_store pk)
else None | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 11,
"end_line": 182,
"start_col": 0,
"start_line": 176
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | private_key: Lib.ByteSequence.lbytes 32
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.Some",
"Spec.P256.PointOps.point_store",
"Spec.P256.PointOps.proj_point",
"Spec.P256.point_mul_g",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Spec.P256.PointOps.order... | [] | false | false | false | false | false | let secret_to_public (private_key: lbytes 32) : option (lbytes 64) =
| let sk = nat_from_bytes_be private_key in
let is_sk_valid = 0 < sk && sk < order in
if is_sk_valid
then
let pk = point_mul_g sk in
Some (point_store pk)
else None | false |
Spec.P256.fst | Spec.P256.pk_compressed_to_raw | val pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64) | val pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64) | let pk_compressed_to_raw (pk:lbytes 33) : option (lbytes 64) =
let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 214,
"start_col": 0,
"start_line": 210
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | pk: Lib.ByteSequence.lbytes 33 -> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes 64) | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"Spec.P256.PointOps.aff_point_decompress",
"Prims.nat",
"FStar.Pervasives.Native.Some",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_to_bytes_be",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.opt... | [] | false | false | false | false | false | let pk_compressed_to_raw (pk: lbytes 33) : option (lbytes 64) =
| let pk_x = sub pk 1 32 in
match (aff_point_decompress pk) with
| Some (x, y) -> Some (concat #_ #32 #32 pk_x (nat_to_bytes_be 32 y))
| None -> None | false |
MiniValeSemantics.fst | MiniValeSemantics.inst_Triple | val inst_Triple:with_wps codes_Triple | val inst_Triple:with_wps codes_Triple | let inst_Triple : with_wps codes_Triple = //A typeclass instance for our program
QSeq (inst_Move (OReg Rbx) (OReg Rax)) (
QSeq (inst_Move (OReg Rbx) (OReg Rax)) (
QSeq (inst_Move (OReg Rbx) (OReg Rax)) (
QSeq (inst_Move (OReg Rbx) (OReg Rax)) (
QSeq (inst_Move (OReg Rbx) (OReg Rax)) (
QSeq (inst_Move (OReg... | {
"file_name": "examples/metatheory/MiniValeSemantics.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 68,
"end_line": 945,
"start_col": 0,
"start_line": 675
} | (*
Copyright 2008-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 agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.FunctionalExtensionality.fsti.checked"
],
"interface_file": false,
"source_file": "MiniValeSemantics.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | MiniValeSemantics.with_wps MiniValeSemantics.codes_Triple | Prims.Tot | [
"total"
] | [] | [
"MiniValeSemantics.QSeq",
"MiniValeSemantics.Ins",
"MiniValeSemantics.Mov64",
"MiniValeSemantics.OReg",
"MiniValeSemantics.Rbx",
"MiniValeSemantics.Rax",
"Prims.Cons",
"MiniValeSemantics.code",
"MiniValeSemantics.Add64",
"Prims.Nil",
"MiniValeSemantics.inst_Move",
"MiniValeSemantics.inst_Add",... | [] | false | false | false | true | false | let inst_Triple:with_wps codes_Triple =
| QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (inst_Move (OReg Rbx) (OReg Rax))
(QSeq (in... | false |
Spec.P256.fst | Spec.P256.pk_compressed_from_raw | val pk_compressed_from_raw (pk: lbytes 64) : lbytes 33 | val pk_compressed_from_raw (pk: lbytes 64) : lbytes 33 | let pk_compressed_from_raw (pk:lbytes 64) : lbytes 33 =
let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in // <==> pk_y % 2 = 1
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x | {
"file_name": "specs/Spec.P256.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 221,
"start_col": 0,
"start_line": 216
} | module Spec.P256
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Spec.Hash.Definitions
module M = Lib.NatMod
module LE = Lib.Exponentiation
module SE = Spec.Exponentiation
module PL = Spec.P256.Lemmas
include Spec.P256.PointOps
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(** https... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.PointOps.fst.checked",
"Spec.P256.Lemmas.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"Spec.Exponentiation.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti... | [
{
"abbrev": false,
"full_module": "Spec.P256.PointOps",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "PL"
},
{
"abbrev": true,
"full_module": "Spec.Exponentiation",
"short_module": "SE"
},
{
"abbrev": true,
"full... | {
"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 | pk: Lib.ByteSequence.lbytes 64 -> Lib.ByteSequence.lbytes 33 | Prims.Tot | [
"total"
] | [] | [
"Lib.ByteSequence.lbytes",
"Lib.Sequence.concat",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.create",
"Lib.IntTypes.int_t",
"Lib.IntTypes.u8",
"Prims.bool",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.Seq... | [] | false | false | false | false | false | let pk_compressed_from_raw (pk: lbytes 64) : lbytes 33 =
| let pk_x = sub pk 0 32 in
let pk_y = sub pk 32 32 in
let is_pk_y_odd = nat_from_bytes_be pk_y % 2 = 1 in
let pk0 = if is_pk_y_odd then u8 0x03 else u8 0x02 in
concat (create 1 pk0) pk_x | false |
LowParse.Tot.Bytes.fst | LowParse.Tot.Bytes.parse_all_bytes | val parse_all_bytes : LowParse.Spec.Base.tot_parser LowParse.Spec.Bytes.parse_all_bytes_kind FStar.Bytes.bytes | let parse_all_bytes = tot_parse_all_bytes | {
"file_name": "src/lowparse/LowParse.Tot.Bytes.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 7,
"start_col": 0,
"start_line": 7
} | module LowParse.Tot.Bytes
include LowParse.Spec.Bytes
include LowParse.Tot.Combinators
include LowParse.Tot.Int | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowParse.Tot.Int.fst.checked",
"LowParse.Tot.Combinators.fst.checked",
"LowParse.Spec.Bytes.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Tot.Bytes.fst"
} | [
{
"abbrev": false,
"full_module": "LowParse.Tot.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Tot.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Bytes",
"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 | LowParse.Spec.Base.tot_parser LowParse.Spec.Bytes.parse_all_bytes_kind FStar.Bytes.bytes | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Bytes.tot_parse_all_bytes"
] | [] | false | false | false | true | false | let parse_all_bytes =
| tot_parse_all_bytes | false | |
SteelNull.fst | SteelNull.main | val main: Prims.unit -> SteelT Int32.t emp (fun _ -> emp) | val main: Prims.unit -> SteelT Int32.t emp (fun _ -> emp) | let main () : SteelT Int32.t emp (fun _ -> emp) =
let r = null #UInt32.t in
if is_null r then
return 0l
else
return 1l | {
"file_name": "share/steel/tests/krml/SteelNull.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 12,
"start_col": 0,
"start_line": 7
} | module SteelNull
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Reference | {
"checked_file": "/",
"dependencies": [
"Steel.Reference.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Int32.fsti.checked"
],
"interface_file": false,
"sourc... | [
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"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 | _: Prims.unit -> Steel.Effect.SteelT FStar.Int32.t | Steel.Effect.SteelT | [] | [] | [
"Prims.unit",
"Steel.Reference.is_null",
"FStar.UInt32.t",
"Steel.Effect.Atomic.return",
"FStar.Int32.t",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"FStar.Algebra.CommMonoid.Equiv.__proj__CM__item__mult",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.req... | [] | false | true | false | false | false | let main () : SteelT Int32.t emp (fun _ -> emp) =
| let r = null #UInt32.t in
if is_null r then return 0l else return 1l | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.define_struct | val define_struct
(n: string)
(#tf #tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 | val define_struct
(n: string)
(#tf #tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 | let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
= define_struct0 tn #tf n fields | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 12,
"start_col": 0,
"start_line": 11
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0 | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 | n: Prims.string -> fields: Pulse.C.Types.Fields.nonempty_field_description_t tf -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.squash",
"FStar.Pervasives.norm",
"Pulse.C.Typestring.norm_typestring",
"Prims.eq2",
"Pulse.C.Typestring.mk_string_t",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"Pulse.C.Types.Struct.define_struct0"
] | [] | false | false | false | false | true | let define_struct
(n: string)
(#tf #tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 =
| define_struct0 tn #tf n fields | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.struct_t | val struct_t
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 | val struct_t
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 | let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
= struct_t0 tn #tf n fields | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 27,
"end_line": 19,
"start_col": 0,
"start_line": 18
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
inline_for_extrac... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 | n: Prims.string -> fields: Pulse.C.Types.Fields.nonempty_field_description_t tf -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.squash",
"FStar.Pervasives.norm",
"Pulse.C.Typestring.norm_typestring",
"Prims.eq2",
"Pulse.C.Typestring.mk_string_t",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"Pulse.C.Types.Struct.struct_t0"
] | [] | false | false | false | false | true | let struct_t
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot Type0 =
| struct_t0 tn #tf n fields | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.struct | val struct
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot (typedef (struct_t0 tn n fields)) | val struct
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot (typedef (struct_t0 tn n fields)) | let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
= struct0 tn #tf n fields | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 25,
"end_line": 92,
"start_col": 0,
"start_line": 91
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
inline_for_extrac... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 | n: Prims.string -> fields: Pulse.C.Types.Fields.nonempty_field_description_t tf
-> Pulse.C.Types.Base.typedef (Pulse.C.Types.Struct.struct_t0 tn n fields) | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Prims.squash",
"FStar.Pervasives.norm",
"Pulse.C.Typestring.norm_typestring",
"Prims.eq2",
"Pulse.C.Typestring.mk_string_t",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"Pulse.C.Types.Struct.struct0",
"Pulse.C.Types.Base.typedef",
"Pulse.C.Types.Struct.struct_t0"
] | [] | false | false | false | false | false | let struct
(#tf: Type0)
(n: string)
(#tn: Type0)
(#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn)))
(fields: nonempty_field_description_t tf)
: Tot (typedef (struct_t0 tn n fields)) =
| struct0 tn #tf n fields | false |
Vale.Def.Words.Two.fst | Vale.Def.Words.Two.nat_to_two_to_nat | val nat_to_two_to_nat (n1 n2:nat32) : Lemma
(nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2)
[SMTPat (nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)))] | val nat_to_two_to_nat (n1 n2:nat32) : Lemma
(nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2)
[SMTPat (nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)))] | let nat_to_two_to_nat (n1 n2:nat32) : Lemma
(nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2)
=
let n = n1 + n2 * pow2_32 in
assert_norm (two_to_nat 32 (Mktwo n1 n2) == int_to_natN pow2_64 n);
assert (0 <= n);
assert (n < pow2_64);
assert (two_to_nat 32 (Mktwo n1 n2) == n);
assert_norm (pow2_... | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Two.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 22,
"start_col": 0,
"start_line": 10
} | module Vale.Def.Words.Two
open FStar.Mul
open Vale.Lib.Meta
let lemma_fundamental_div_mod (x:nat64) :
Lemma (x = x % pow2_32 + pow2_32 * ((x / pow2_32) % pow2_32))
=
() | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Meta.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Def.Words.Two.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n1: Vale.Def.Words_s.nat32 -> n2: Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Two_s.nat_to_two 32
(Vale.Def.Words.Two_s.two_to_nat 32 (Vale.Def.Words_s.Mktwo n1 n2)) ==
Vale.Def.Words_s.Mktwo n1 n2)
[
SMTPat (Vale.Def.Words.Two_s.nat_to_two 32... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Vale.Def.Words.Two.lemma_fundamental_div_mod",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Two_s.nat_to_two",
"Vale.Def.Words_s.Mktwo",
"Prims.op_Modulus",
"Vale.Def.Words_s... | [] | true | false | true | false | false | let nat_to_two_to_nat (n1 n2: nat32)
: Lemma (nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2) =
| let n = n1 + n2 * pow2_32 in
assert_norm (two_to_nat 32 (Mktwo n1 n2) == int_to_natN pow2_64 n);
assert (0 <= n);
assert (n < pow2_64);
assert (two_to_nat 32 (Mktwo n1 n2) == n);
assert_norm (pow2_norm 32 == pow2_32);
assert_norm (nat_to_two 32 n == Mktwo (n % pow2_32) ((n / pow2_32) % pow2_32));
lemma_fundamental_div_... | false |
Vale.Def.Words.Two.fst | Vale.Def.Words.Two.two_to_nat_to_two | val two_to_nat_to_two (n:nat64) : Lemma
(two_to_nat 32 (nat_to_two 32 n) == n)
[SMTPat (two_to_nat 32 (nat_to_two 32 n))] | val two_to_nat_to_two (n:nat64) : Lemma
(two_to_nat 32 (nat_to_two 32 n) == n)
[SMTPat (two_to_nat 32 (nat_to_two 32 n))] | let two_to_nat_to_two (n:nat64) =
let n1 = n % (pow2_32) in
let n2 = (n/(pow2_32)) % (pow2_32) in
let n_f = two_to_nat 32 (Mktwo n1 n2) in
assert_norm (n == n1 + n2 * pow2_32) | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Two.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 28,
"start_col": 0,
"start_line": 24
} | module Vale.Def.Words.Two
open FStar.Mul
open Vale.Lib.Meta
let lemma_fundamental_div_mod (x:nat64) :
Lemma (x = x % pow2_32 + pow2_32 * ((x / pow2_32) % pow2_32))
=
()
let nat_to_two_to_nat (n1 n2:nat32) : Lemma
(nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2)
=
let n = n1 + n2 * pow2_32 in
... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Meta.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Def.Words.Two.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Vale.Def.Words_s.nat64
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Words.Two_s.two_to_nat 32 (Vale.Def.Words.Two_s.nat_to_two 32 n) == n)
[SMTPat (Vale.Def.Words.Two_s.two_to_nat 32 (Vale.Def.Words.Two_s.nat_to_two 32 n))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Words_s.nat64",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.pow2_32",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Prims.op_Multiply",
"Vale.Def.Words.Two_s.two_to_nat",
"Vale.Def.Words_s.Mktwo",
"Prims.op_Modulus... | [] | true | false | true | false | false | let two_to_nat_to_two (n: nat64) =
| let n1 = n % (pow2_32) in
let n2 = (n / (pow2_32)) % (pow2_32) in
let n_f = two_to_nat 32 (Mktwo n1 n2) in
assert_norm (n == n1 + n2 * pow2_32) | false |
Vale.Def.Words.Two.fst | Vale.Def.Words.Two.two_to_nat_32_injective | val two_to_nat_32_injective (_:unit) : Lemma
(forall (x x':two (natN (pow2_norm 32))).{:pattern two_to_nat 32 x; two_to_nat 32 x'}
two_to_nat 32 x == two_to_nat 32 x' ==> x == x') | val two_to_nat_32_injective (_:unit) : Lemma
(forall (x x':two (natN (pow2_norm 32))).{:pattern two_to_nat 32 x; two_to_nat 32 x'}
two_to_nat 32 x == two_to_nat 32 x' ==> x == x') | let two_to_nat_32_injective () =
generic_injective_proof (two_to_nat 32) (nat_to_two 32) (fun x -> nat_to_two_to_nat x.lo x.hi) | {
"file_name": "vale/code/lib/util/Vale.Def.Words.Two.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 96,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | module Vale.Def.Words.Two
open FStar.Mul
open Vale.Lib.Meta
let lemma_fundamental_div_mod (x:nat64) :
Lemma (x = x % pow2_32 + pow2_32 * ((x / pow2_32) % pow2_32))
=
()
let nat_to_two_to_nat (n1 n2:nat32) : Lemma
(nat_to_two 32 (two_to_nat 32 (Mktwo n1 n2)) == Mktwo n1 n2)
=
let n = n1 + n2 * pow2_32 in
... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Meta.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": true,
"source_file": "Vale.Def.Words.Two.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.Lib.Meta",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (x: Vale.Def.Words_s.two (Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 32)))
(x': Vale.Def.Words_s.two (Vale.Def.Words_s.natN (Vale.Def.Words_s.pow2_norm 32))).
{:pattern Vale.Def.Words.Two_s.two_to_nat 32 x; Vale.Def.Words.Two_s.t... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Vale.Lib.Meta.generic_injective_proof",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words.Two_s.two_to_nat",
"Vale.Def.Words.Two_s.nat_to_two",
"Vale.Def.Words.Two.nat_to_two_to_nat",
"Vale.Def.Words_s.__p... | [] | false | false | true | false | false | let two_to_nat_32_injective () =
| generic_injective_proof (two_to_nat 32) (nat_to_two 32) (fun x -> nat_to_two_to_nat x.lo x.hi) | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_64_lseq_lemma | val proj_g_pow2_64_lseq_lemma: unit ->
Lemma (point_inv_seq proj_g_pow2_64_lseq /\
S.to_aff_point (from_mont_point (as_point_nat_seq proj_g_pow2_64_lseq)) == g_pow2_64) | val proj_g_pow2_64_lseq_lemma: unit ->
Lemma (point_inv_seq proj_g_pow2_64_lseq /\
S.to_aff_point (from_mont_point (as_point_nat_seq proj_g_pow2_64_lseq)) == g_pow2_64) | let proj_g_pow2_64_lseq_lemma () =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_64);
proj_g_pow2_64_lemma ();
SPTK.proj_point_to_list_lemma proj_g_pow2_64 | {
"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": 46,
"end_line": 171,
"start_col": 0,
"start_line": 168
} | 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": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"... | {
"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
Hacl.Impl.P256.Point.point_inv_seq Hacl.P256.PrecompTable.proj_g_pow2_64_lseq /\
Spec.P256.PointOps.to_aff_point (Hacl.Impl.P256.Point.from_mont_point (Hacl.Impl.P256.Point.as_point_nat_seq
Hacl.P256.PrecompTable.proj_g_pow2_64_lseq)) ==... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Hacl.Spec.P256.PrecompTable.proj_point_to_list_lemma",
"Hacl.P256.PrecompTable.proj_g_pow2_64",
"Hacl.P256.PrecompTable.proj_g_pow2_64_lemma",
"FStar.Pervasives.normalize_term_spec",
"Hacl.Spec.P256.PrecompTable.point_list",
"Hacl.Spec.P256.PrecompTable.proj_point_to_list"
] | [] | true | false | true | false | false | let proj_g_pow2_64_lseq_lemma () =
| normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_64);
proj_g_pow2_64_lemma ();
SPTK.proj_point_to_list_lemma proj_g_pow2_64 | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_128_list | val proj_g_pow2_128_list:SPTK.point_list | val proj_g_pow2_128_list:SPTK.point_list | let proj_g_pow2_128_list : SPTK.point_list =
normalize_term (SPTK.proj_point_to_list proj_g_pow2_128) | {
"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": 58,
"end_line": 121,
"start_col": 0,
"start_line": 120
} | 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 | Hacl.Spec.P256.PrecompTable.point_list | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Hacl.Spec.P256.PrecompTable.point_list",
"Hacl.Spec.P256.PrecompTable.proj_point_to_list",
"Hacl.P256.PrecompTable.proj_g_pow2_128"
] | [] | false | false | false | true | false | let proj_g_pow2_128_list:SPTK.point_list =
| normalize_term (SPTK.proj_point_to_list proj_g_pow2_128) | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.struct_get_field_pat | val struct_get_field_pat
(#tn #tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(s: struct_t0 tn n fields)
(field: field_t fields)
(v: fields.fd_type field)
(field': field_t fields)
: Lemma
(struct_get_field (struct_set_field field v s) field' ==
... | val struct_get_field_pat
(#tn #tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(s: struct_t0 tn n fields)
(field: field_t fields)
(v: fields.fd_type field)
(field': field_t fields)
: Lemma
(struct_get_field (struct_set_field field v s) field' ==
... | let struct_get_field_pat
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(s: struct_t0 tn n fields)
(field: field_t fields)
(v: fields.fd_type field)
(field': field_t fields)
: Lemma
(struct_get_field (struct_set_field field v s) field' == (if field' = field then v el... | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 46,
"end_line": 84,
"start_col": 0,
"start_line": 70
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
inline_for_extrac... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 |
s: Pulse.C.Types.Struct.struct_t0 tn n fields ->
field: Pulse.C.Types.Fields.field_t fields ->
v: Mkfield_description_t?.fd_type fields field ->
field': Pulse.C.Types.Fields.field_t fields
-> FStar.Pervasives.Lemma
(ensures
Pulse.C.Types.Struct.struct_get_field (Pulse.C.Types.Struct.str... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.string",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"Pulse.C.Types.Struct.struct_t0",
"Pulse.C.Types.Fields.field_t",
"Pulse.C.Types.Fields.__proj__Mkfield_description_t__item__fd_type",
"Prims.op_Equality",
"Prims.bool",
"Pulse.C.Types.Struct.struct_get_field_other",
"Prims.unit",
... | [] | false | false | true | false | false | let struct_get_field_pat
(#tn #tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(s: struct_t0 tn n fields)
(field: field_t fields)
(v: fields.fd_type field)
(field': field_t fields)
: Lemma
(struct_get_field (struct_set_field field v s) field' ==
... | if field' = field then () else struct_get_field_other s field v field' | false |
Hacl.HPKE.Curve51_CP256_SHA256.fsti | Hacl.HPKE.Curve51_CP256_SHA256.cs | val cs:S.ciphersuite | val cs:S.ciphersuite | let cs:S.ciphersuite = (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | {
"file_name": "code/hpke/Hacl.HPKE.Curve51_CP256_SHA256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 102,
"end_line": 10,
"start_col": 0,
"start_line": 10
} | module Hacl.HPKE.Curve51_CP256_SHA256
open Hacl.Impl.HPKE
module S = Spec.Agile.HPKE
module DH = Spec.Agile.DH
module AEAD = Spec.Agile.AEAD
module Hash = Spec.Agile.Hash | {
"checked_file": "/",
"dependencies": [
"Spec.Agile.HPKE.fsti.checked",
"Spec.Agile.Hash.fsti.checked",
"Spec.Agile.DH.fst.checked",
"Spec.Agile.AEAD.fsti.checked",
"prims.fst.checked",
"Hacl.Impl.HPKE.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.chec... | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": true,
"full_module": "Spec.Agile.AEAD",
"short_module": "AEAD"
},
{
"abbrev": true,
"full_module": "Spec.Agile.DH",
"short_module": "DH"
},
{
"abbrev": true,
"full_module... | {
"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 | Spec.Agile.HPKE.ciphersuite | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.Mktuple4",
"Spec.Agile.DH.algorithm",
"Spec.Agile.HPKE.hash_algorithm",
"Spec.Agile.HPKE.aead",
"Spec.Hash.Definitions.hash_alg",
"Spec.Agile.DH.DH_Curve25519",
"Spec.Hash.Definitions.SHA2_256",
"Spec.Agile.HPKE.Seal",
"Spec.Agile.AEAD.CHACHA20_POLY1305"
] | [] | false | false | false | true | false | let cs:S.ciphersuite =
| (DH.DH_Curve25519, Hash.SHA2_256, S.Seal AEAD.CHACHA20_POLY1305, Hash.SHA2_256) | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.struct_field1 | val struct_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': sq... | val struct_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': sq... | let struct_field1
(#tn: Type0)
(#tf: Type0)
(t': Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': squash (td' == ... | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 268,
"start_col": 0,
"start_line": 253
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
inline_for_extrac... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 |
t': Type0 ->
r: Pulse.C.Types.Base.ref (Pulse.C.Types.Struct.struct0 tn n fields) ->
field: Pulse.C.Types.Fields.field_t fields ->
td': Pulse.C.Types.Base.typedef t' ->
sq_t': Prims.squash (t' == Mkfield_description_t?.fd_type fields field) ->
sq_td': Prims.squash (td' == Mkfield_description_t?... | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"FStar.Ghost.erased",
"Pulse.C.Types.Struct.struct_t0",
"Pulse.C.Types.Base.ref",
"Pulse.C.Types.Struct.struct0",
"Pulse.C.Types.Fields.field_t",
"Pulse.C.Types.Base.typedef",
"Prims.squash",
"Prims.eq2",
"Pulse.C.Types.Fields.... | [] | false | false | false | false | false | let struct_field1
(#tn #tf t': Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(td': typedef t')
(sq_t': squash (t' == fields.fd_type field))
(sq_td': sq... | struct_field0 t' r field td' | false |
FStar.Buffer.fst | FStar.Buffer.blit | val blit: #t:Type
-> a:buffer t
-> idx_a:UInt32.t{v idx_a <= length a}
-> b:buffer t{disjoint a b}
-> idx_b:UInt32.t{v idx_b <= length b}
-> len:UInt32.t{v idx_a + v len <= length a /\ v idx_b + v len <= length b}
-> Stack unit
(requires (fun h -> live h a /\ live h b))
(ensures (fun h0 _ h1 -> liv... | val blit: #t:Type
-> a:buffer t
-> idx_a:UInt32.t{v idx_a <= length a}
-> b:buffer t{disjoint a b}
-> idx_b:UInt32.t{v idx_b <= length b}
-> len:UInt32.t{v idx_a + v len <= length a /\ v idx_b + v len <= length b}
-> Stack unit
(requires (fun h -> live h a /\ live h b))
(ensures (fun h0 _ h1 -> liv... | let rec blit #t a idx_a b idx_b len =
let h0 = HST.get () in
if len =^ 0ul then ()
else
begin
let len' = len -^ 1ul in
blit #t a idx_a b idx_b len';
let z = a.(idx_a +^ len') in
b.(idx_b +^ len') <- z;
let h1 = HST.get() in
Seq.snoc_slice_index (as_seq h1 b) (v idx_b) (v idx_b + v len'... | {
"file_name": "ulib/legacy/FStar.Buffer.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 7,
"end_line": 1186,
"start_col": 0,
"start_line": 1173
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.TSet.fsti.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Map.f... | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_modu... | {
"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: FStar.Buffer.buffer t ->
idx_a: FStar.UInt32.t{FStar.UInt32.v idx_a <= FStar.Buffer.length a} ->
b: FStar.Buffer.buffer t {FStar.Buffer.disjoint a b} ->
idx_b: FStar.UInt32.t{FStar.UInt32.v idx_b <= FStar.Buffer.length b} ->
len:
FStar.UInt32.t
{ FStar.UInt32.v idx_a + FStar.UInt32... | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Buffer.length",
"FStar.Buffer.disjoint",
"Prims.l_and",
"Prims.op_Addition",
"FStar.UInt32.op_Equals_Hat",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims.bool",
"FStar.Seq.Propertie... | [
"recursion"
] | false | true | false | false | false | let rec blit #t a idx_a b idx_b len =
| let h0 = HST.get () in
if len =^ 0ul
then ()
else
let len' = len -^ 1ul in
blit #t a idx_a b idx_b len';
let z = a.(idx_a +^ len') in
b.(idx_b +^ len') <- z;
let h1 = HST.get () in
Seq.snoc_slice_index (as_seq h1 b) (v idx_b) (v idx_b + v len');
Seq.cons_head_tail (Seq.slice (as_seq h0 b) (v idx_b + v len... | false |
Pulse.C.Types.Struct.fsti | Pulse.C.Types.Struct.struct_field | val struct_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: nonempty_field_description_t tf ->
#v: Ghost.erased (struct_t0 tn n fields) ->
r: ref (struct0 tn n fields) ->
field: field_t fields ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == f... | val struct_field:
#tn: Type0 ->
#tf: Type0 ->
#n: string ->
#fields: nonempty_field_description_t tf ->
#v: Ghost.erased (struct_t0 tn n fields) ->
r: ref (struct0 tn n fields) ->
field: field_t fields ->
#t': Type0 ->
#td': typedef t' ->
(#[norm_fields ()] sq_t': squash (t' == f... | let struct_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(# [ norm_fields () ] sq_t': squash (t' == fields.fd_type field))
(#... | {
"file_name": "share/steel/examples/pulse/lib/c/Pulse.C.Types.Struct.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 291,
"start_col": 0,
"start_line": 271
} | module Pulse.C.Types.Struct
open Pulse.Lib.Pervasives
include Pulse.C.Types.Fields
open Pulse.C.Typestring
// To be extracted as: struct t { fields ... }
[@@noextract_to "krml"] // primitive
val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
inline_for_extrac... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"Pulse.C.Typestring.fsti.checked",
"Pulse.C.Types.Fields.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.C.Type... | [
{
"abbrev": false,
"full_module": "Pulse.C.Typestring",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.C.Types.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"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 |
r: Pulse.C.Types.Base.ref (Pulse.C.Types.Struct.struct0 tn n fields) ->
field: Pulse.C.Types.Fields.field_t fields ->
_: Prims.unit
-> Pulse.Lib.Core.stt (Pulse.C.Types.Base.ref td')
(Pulse.C.Types.Base.pts_to r v)
(fun r' ->
(Pulse.C.Types.Base.pts_to r
(FStar.Ghost.hid... | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"Pulse.C.Types.Fields.nonempty_field_description_t",
"FStar.Ghost.erased",
"Pulse.C.Types.Struct.struct_t0",
"Pulse.C.Types.Base.ref",
"Pulse.C.Types.Struct.struct0",
"Pulse.C.Types.Fields.field_t",
"Pulse.C.Types.Base.typedef",
"Prims.squash",
"Prims.eq2",
"Pulse.C.Types.Fields.... | [] | false | false | false | false | false | let struct_field
(#tn: Type0)
(#tf: Type0)
(#n: string)
(#fields: nonempty_field_description_t tf)
(#v: Ghost.erased (struct_t0 tn n fields))
(r: ref (struct0 tn n fields))
(field: field_t fields)
(#t': Type0)
(#td': typedef t')
(#[norm_fields ()] sq_t': squas... | struct_field0 t' r field td' | false |
Hacl.Impl.Frodo.KEM.KeyGen.fst | Hacl.Impl.Frodo.KEM.KeyGen.clear_matrix2 | val clear_matrix2:
a:FP.frodo_alg
-> s_matrix:matrix_t (params_n a) params_nbar
-> e_matrix:matrix_t (params_n a) params_nbar
-> Stack unit
(requires fun h ->
live h s_matrix /\ live h e_matrix /\
disjoint s_matrix e_matrix)
(ensures fun h0 _ h1 ->
modifies (loc s_matrix |+| loc e_m... | val clear_matrix2:
a:FP.frodo_alg
-> s_matrix:matrix_t (params_n a) params_nbar
-> e_matrix:matrix_t (params_n a) params_nbar
-> Stack unit
(requires fun h ->
live h s_matrix /\ live h e_matrix /\
disjoint s_matrix e_matrix)
(ensures fun h0 _ h1 ->
modifies (loc s_matrix |+| loc e_m... | let clear_matrix2 a s_matrix e_matrix =
clear_matrix s_matrix;
clear_matrix e_matrix | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.KeyGen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 147,
"start_col": 0,
"start_line": 145
} | module Hacl.Impl.Frodo.KEM.KeyGen
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Impl.Frodo.Pack
open Hacl.Impl.Frodo.Sample
open Hacl.Frodo.Random
module ST = F... | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "M"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Spec.Frodo.Params.frodo_alg ->
s_matrix:
Hacl.Impl.Matrix.matrix_t (Hacl.Impl.Frodo.Params.params_n a)
Hacl.Impl.Frodo.Params.params_nbar ->
e_matrix:
Hacl.Impl.Matrix.matrix_t (Hacl.Impl.Frodo.Params.params_n a)
Hacl.Impl.Frodo.Params.params_nbar
-> FStar.HyperStack.ST.Sta... | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Hacl.Impl.Matrix.matrix_t",
"Hacl.Impl.Frodo.Params.params_n",
"Hacl.Impl.Frodo.Params.params_nbar",
"Hacl.Impl.Frodo.KEM.clear_matrix",
"Prims.unit"
] | [] | false | true | false | false | false | let clear_matrix2 a s_matrix e_matrix =
| clear_matrix s_matrix;
clear_matrix e_matrix | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_192_lemma | val proj_g_pow2_192_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_192 == pow_point (pow2 192) g_aff) | val proj_g_pow2_192_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_192 == pow_point (pow2 192) g_aff) | let proj_g_pow2_192_lemma () =
lemma_proj_g_pow2_192_eval ();
lemma_proj_g_pow2_128_eval ();
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_192_lemma S.mk_p256_concrete_ops S.base_point | {
"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": 61,
"end_line": 165,
"start_col": 0,
"start_line": 161
} | 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.P256.PointOps.to_aff_point Hacl.P256.PrecompTable.proj_g_pow2_192 ==
Hacl.P256.PrecompTable.pow_point (Prims.pow2 192) Hacl.P256.PrecompTable.g_aff) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Hacl.Spec.PrecompBaseTable256.a_pow2_192_lemma",
"Spec.P256.PointOps.proj_point",
"Spec.P256.mk_p256_concrete_ops",
"Spec.P256.PointOps.base_point",
"Hacl.P256.PrecompTable.lemma_proj_g_pow2_64_eval",
"Hacl.P256.PrecompTable.lemma_proj_g_pow2_128_eval",
"Hacl.P256.PrecompTable.lemma_pro... | [] | true | false | true | false | false | let proj_g_pow2_192_lemma () =
| lemma_proj_g_pow2_192_eval ();
lemma_proj_g_pow2_128_eval ();
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_192_lemma S.mk_p256_concrete_ops S.base_point | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_64_list | val proj_g_pow2_64_list:SPTK.point_list | val proj_g_pow2_64_list:SPTK.point_list | let proj_g_pow2_64_list : SPTK.point_list =
normalize_term (SPTK.proj_point_to_list proj_g_pow2_64) | {
"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": 57,
"end_line": 117,
"start_col": 0,
"start_line": 116
} | 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 | Hacl.Spec.P256.PrecompTable.point_list | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Hacl.Spec.P256.PrecompTable.point_list",
"Hacl.Spec.P256.PrecompTable.proj_point_to_list",
"Hacl.P256.PrecompTable.proj_g_pow2_64"
] | [] | false | false | false | true | false | let proj_g_pow2_64_list:SPTK.point_list =
| normalize_term (SPTK.proj_point_to_list proj_g_pow2_64) | false |
Hacl.Impl.Frodo.KEM.KeyGen.fst | Hacl.Impl.Frodo.KEM.KeyGen.frodo_shake_r | val frodo_shake_r:
a:FP.frodo_alg
-> c:uint8
-> seed_se:lbytes (crypto_bytes a)
-> output_len:size_t
-> r:lbytes output_len
-> Stack unit
(requires fun h ->
live h seed_se /\ live h r /\ disjoint seed_se r)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
as_seq h1 r == S.frodo_shake... | val frodo_shake_r:
a:FP.frodo_alg
-> c:uint8
-> seed_se:lbytes (crypto_bytes a)
-> output_len:size_t
-> r:lbytes output_len
-> Stack unit
(requires fun h ->
live h seed_se /\ live h r /\ disjoint seed_se r)
(ensures fun h0 _ h1 -> modifies (loc r) h0 h1 /\
as_seq h1 r == S.frodo_shake... | let frodo_shake_r a c seed_se output_len r =
push_frame ();
let h0 = ST.get () in
let shake_input_seed_se = create (1ul +! crypto_bytes a) (u8 0) in
shake_input_seed_se.(0ul) <- c;
update_sub shake_input_seed_se 1ul (crypto_bytes a) seed_se;
let h2 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h2 shake_i... | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.KeyGen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 53,
"start_col": 0,
"start_line": 41
} | module Hacl.Impl.Frodo.KEM.KeyGen
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Impl.Frodo.Pack
open Hacl.Impl.Frodo.Sample
open Hacl.Frodo.Random
module ST = F... | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "M"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Spec.Frodo.Params.frodo_alg ->
c: Lib.IntTypes.uint8 ->
seed_se: Hacl.Impl.Matrix.lbytes (Hacl.Impl.Frodo.Params.crypto_bytes a) ->
output_len: Lib.IntTypes.size_t ->
r: Hacl.Impl.Matrix.lbytes output_len
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Lib.IntTypes.uint8",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Lib.IntTypes.size_t",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Frodo.KEM.clear_words_u8",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
... | [] | false | true | false | false | false | let frodo_shake_r a c seed_se output_len r =
| push_frame ();
let h0 = ST.get () in
let shake_input_seed_se = create (1ul +! crypto_bytes a) (u8 0) in
shake_input_seed_se.(0ul) <- c;
update_sub shake_input_seed_se 1ul (crypto_bytes a) seed_se;
let h2 = ST.get () in
LSeq.eq_intro (LSeq.sub (as_seq h2 shake_input_seed_se) 0 1) (LSeq.create 1 c);
LSeq.eq_intro (LSeq.s... | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_64_lemma | val proj_g_pow2_64_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_64 == pow_point (pow2 64) g_aff) | val proj_g_pow2_64_lemma: unit ->
Lemma (S.to_aff_point proj_g_pow2_64 == pow_point (pow2 64) g_aff) | let proj_g_pow2_64_lemma () =
lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_64_lemma S.mk_p256_concrete_ops S.base_point | {
"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": 60,
"end_line": 146,
"start_col": 0,
"start_line": 144
} | 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.P256.PointOps.to_aff_point Hacl.P256.PrecompTable.proj_g_pow2_64 ==
Hacl.P256.PrecompTable.pow_point (Prims.pow2 64) Hacl.P256.PrecompTable.g_aff) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"Hacl.Spec.PrecompBaseTable256.a_pow2_64_lemma",
"Spec.P256.PointOps.proj_point",
"Spec.P256.mk_p256_concrete_ops",
"Spec.P256.PointOps.base_point",
"Hacl.P256.PrecompTable.lemma_proj_g_pow2_64_eval"
] | [] | true | false | true | false | false | let proj_g_pow2_64_lemma () =
| lemma_proj_g_pow2_64_eval ();
SPT256.a_pow2_64_lemma S.mk_p256_concrete_ops S.base_point | false |
Hacl.P256.PrecompTable.fst | Hacl.P256.PrecompTable.proj_g_pow2_192_lseq | val proj_g_pow2_192_lseq : LSeq.lseq uint64 12 | val proj_g_pow2_192_lseq : LSeq.lseq uint64 12 | let proj_g_pow2_192_lseq : LSeq.lseq uint64 12 =
normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_192);
Seq.seq_of_list proj_g_pow2_192_list | {
"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": 38,
"end_line": 138,
"start_col": 0,
"start_line": 136
} | 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": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.P256.PrecompTable",
"short_module": "SPTK"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.PrecompBaseTable256",
"short_module": "SPT256"
},
{
"... | {
"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 | Lib.Sequence.lseq Lib.IntTypes.uint64 12 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq_of_list",
"Lib.IntTypes.uint64",
"Hacl.P256.PrecompTable.proj_g_pow2_192_list",
"Prims.unit",
"FStar.Pervasives.normalize_term_spec",
"Hacl.Spec.P256.PrecompTable.point_list",
"Hacl.Spec.P256.PrecompTable.proj_point_to_list",
"Hacl.P256.PrecompTable.proj_g_pow2_192",
"Lib.Sequenc... | [] | false | false | false | false | false | let proj_g_pow2_192_lseq:LSeq.lseq uint64 12 =
| normalize_term_spec (SPTK.proj_point_to_list proj_g_pow2_192);
Seq.seq_of_list proj_g_pow2_192_list | false |
Hacl.Impl.Frodo.KEM.KeyGen.fst | Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_keypair_ | val crypto_kem_keypair_:
a:FP.frodo_alg
-> gen_a:FP.frodo_gen_a{is_supported gen_a}
-> coins:lbytes (size 2 *! crypto_bytes a +! bytes_seed_a)
-> pk:lbytes (crypto_publickeybytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> Stack unit
(requires fun h ->
live h pk /\ live h sk /\ live h coins /\
... | val crypto_kem_keypair_:
a:FP.frodo_alg
-> gen_a:FP.frodo_gen_a{is_supported gen_a}
-> coins:lbytes (size 2 *! crypto_bytes a +! bytes_seed_a)
-> pk:lbytes (crypto_publickeybytes a)
-> sk:lbytes (crypto_secretkeybytes a)
-> Stack unit
(requires fun h ->
live h pk /\ live h sk /\ live h coins /\
... | let crypto_kem_keypair_ a gen_a coins pk sk =
FP.expand_crypto_secretkeybytes a;
FP.expand_crypto_secretkeybytes a;
let h0 = ST.get () in
let s = sub coins 0ul (crypto_bytes a) in
let seed_se = sub coins (crypto_bytes a) (crypto_bytes a) in
let z = sub coins (2ul *! crypto_bytes a) bytes_seed_a in
let se... | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.KeyGen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 280,
"start_col": 0,
"start_line": 263
} | module Hacl.Impl.Frodo.KEM.KeyGen
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Impl.Frodo.Pack
open Hacl.Impl.Frodo.Sample
open Hacl.Frodo.Random
module ST = F... | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "M"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} ->
coins:
Hacl.Impl.Matrix.lbytes (Lib.IntTypes.size 2 *! Hacl.Impl.Frodo.Params.crypto_bytes a +!
Hacl.Impl.Frodo.Params.bytes_seed_a) ->
pk: Hacl.Impl.Matrix.lbytes (Hacl.... | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.size",
"Hacl.Impl.Frodo.Params.crypto_byt... | [] | false | true | false | false | false | let crypto_kem_keypair_ a gen_a coins pk sk =
| FP.expand_crypto_secretkeybytes a;
FP.expand_crypto_secretkeybytes a;
let h0 = ST.get () in
let s = sub coins 0ul (crypto_bytes a) in
let seed_se = sub coins (crypto_bytes a) (crypto_bytes a) in
let z = sub coins (2ul *! crypto_bytes a) bytes_seed_a in
let seed_a = sub pk 0ul bytes_seed_a in
frodo_shake a bytes_seed_a ... | false |
Hacl.Impl.Frodo.KEM.KeyGen.fst | Hacl.Impl.Frodo.KEM.KeyGen.crypto_kem_sk1 | val crypto_kem_sk1:
a:FP.frodo_alg
-> s:lbytes (crypto_bytes a)
-> pk:lbytes (crypto_publickeybytes a)
-> sk:lbytes (crypto_secretkeybytes a -! bytes_pkhash a)
-> Stack unit
(requires fun h ->
live h pk /\ live h sk /\ live h s /\
disjoint pk sk /\ disjoint sk s)
(ensures fun h0 _ h1 ->... | val crypto_kem_sk1:
a:FP.frodo_alg
-> s:lbytes (crypto_bytes a)
-> pk:lbytes (crypto_publickeybytes a)
-> sk:lbytes (crypto_secretkeybytes a -! bytes_pkhash a)
-> Stack unit
(requires fun h ->
live h pk /\ live h sk /\ live h s /\
disjoint pk sk /\ disjoint sk s)
(ensures fun h0 _ h1 ->... | let crypto_kem_sk1 a s pk sk =
let h1 = ST.get () in
FP.expand_crypto_secretkeybytes a;
let s_pk_len = crypto_bytes a +! crypto_publickeybytes a in
[@inline_let] let sm_len = secretmatrixbytes_len a in
let slen1 = crypto_secretkeybytes a -! bytes_pkhash a in
let s_bytes = sub sk s_pk_len sm_len in
update... | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.KeyGen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 215,
"start_col": 0,
"start_line": 194
} | module Hacl.Impl.Frodo.KEM.KeyGen
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Impl.Frodo.Pack
open Hacl.Impl.Frodo.Sample
open Hacl.Frodo.Random
module ST = F... | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "M"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Spec.Frodo.Params.frodo_alg ->
s: Hacl.Impl.Matrix.lbytes (Hacl.Impl.Frodo.Params.crypto_bytes a) ->
pk: Hacl.Impl.Matrix.lbytes (Hacl.Impl.Frodo.Params.crypto_publickeybytes a) ->
sk:
Hacl.Impl.Matrix.lbytes (Hacl.Impl.Frodo.Params.crypto_secretkeybytes a -!
Hacl.Impl.Frodo.Params.b... | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Lib.IntTypes.op_Subtraction_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Impl.Frodo.Params.bytes_p... | [] | false | true | false | false | false | let crypto_kem_sk1 a s pk sk =
| let h1 = ST.get () in
FP.expand_crypto_secretkeybytes a;
let s_pk_len = crypto_bytes a +! crypto_publickeybytes a in
[@@ inline_let ]let sm_len = secretmatrixbytes_len a in
let slen1 = crypto_secretkeybytes a -! bytes_pkhash a in
let s_bytes = sub sk s_pk_len sm_len in
update_sub sk 0ul (crypto_bytes a) s;
let h2 = ST.... | false |
Hacl.Impl.Frodo.KEM.KeyGen.fst | Hacl.Impl.Frodo.KEM.KeyGen.frodo_mul_add_as_plus_e | val frodo_mul_add_as_plus_e:
a:FP.frodo_alg
-> gen_a:FP.frodo_gen_a{is_supported gen_a}
-> seed_a:lbytes bytes_seed_a
-> s_matrix:matrix_t (params_n a) params_nbar
-> e_matrix:matrix_t (params_n a) params_nbar
-> b_matrix:matrix_t (params_n a) params_nbar
-> Stack unit
(requires fun h ->
live ... | val frodo_mul_add_as_plus_e:
a:FP.frodo_alg
-> gen_a:FP.frodo_gen_a{is_supported gen_a}
-> seed_a:lbytes bytes_seed_a
-> s_matrix:matrix_t (params_n a) params_nbar
-> e_matrix:matrix_t (params_n a) params_nbar
-> b_matrix:matrix_t (params_n a) params_nbar
-> Stack unit
(requires fun h ->
live ... | let frodo_mul_add_as_plus_e a gen_a seed_a s_matrix e_matrix b_matrix =
FP.params_n_sqr a;
push_frame();
let a_matrix = matrix_create (params_n a) (params_n a) in
frodo_gen_matrix gen_a (params_n a) seed_a a_matrix;
matrix_mul_s a_matrix s_matrix b_matrix;
matrix_add b_matrix e_matrix;
pop_frame() | {
"file_name": "code/frodo/Hacl.Impl.Frodo.KEM.KeyGen.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 80,
"start_col": 0,
"start_line": 73
} | module Hacl.Impl.Frodo.KEM.KeyGen
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Hacl.Impl.Matrix
open Hacl.Impl.Frodo.Params
open Hacl.Impl.Frodo.KEM
open Hacl.Impl.Frodo.Pack
open Hacl.Impl.Frodo.Sample
open Hacl.Frodo.Random
module ST = F... | {
"checked_file": "/",
"dependencies": [
"Spec.Matrix.fst.checked",
"Spec.Frodo.Params.fst.checked",
"Spec.Frodo.KEM.KeyGen.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.KEM.KeyGen",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": true,
"full_module": "Spec.Matrix",
"short_module": "M"
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Spec.Frodo.Params.frodo_alg ->
gen_a: Spec.Frodo.Params.frodo_gen_a{Hacl.Impl.Frodo.Params.is_supported gen_a} ->
seed_a: Hacl.Impl.Matrix.lbytes Hacl.Impl.Frodo.Params.bytes_seed_a ->
s_matrix:
Hacl.Impl.Matrix.matrix_t (Hacl.Impl.Frodo.Params.params_n a)
Hacl.Impl.Frodo.Params.params... | FStar.HyperStack.ST.Stack | [] | [] | [
"Spec.Frodo.Params.frodo_alg",
"Spec.Frodo.Params.frodo_gen_a",
"Prims.b2t",
"Hacl.Impl.Frodo.Params.is_supported",
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.bytes_seed_a",
"Hacl.Impl.Matrix.matrix_t",
"Hacl.Impl.Frodo.Params.params_n",
"Hacl.Impl.Frodo.Params.params_nbar",
"FStar.HyperSt... | [] | false | true | false | false | false | let frodo_mul_add_as_plus_e a gen_a seed_a s_matrix e_matrix b_matrix =
| FP.params_n_sqr a;
push_frame ();
let a_matrix = matrix_create (params_n a) (params_n a) in
frodo_gen_matrix gen_a (params_n a) seed_a a_matrix;
matrix_mul_s a_matrix s_matrix b_matrix;
matrix_add b_matrix e_matrix;
pop_frame () | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.