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.Modifies.fst | FStar.Modifies.buffer_live_mreference_unused_in_disjoint | val buffer_live_mreference_unused_in_disjoint
(#t1: Type)
(#t2: Type)
(#pre: Preorder.preorder t2)
(h: HS.mem)
(b1: B.buffer t1)
(b2: HS.mreference t2 pre)
: Lemma
(requires (B.live h b1 /\ HS.unused_in b2 h))
(ensures (loc_disjoint (loc_buffer b1) (loc_freed_mreference b2)))
[SMTPat (B.live h b1); SM... | val buffer_live_mreference_unused_in_disjoint
(#t1: Type)
(#t2: Type)
(#pre: Preorder.preorder t2)
(h: HS.mem)
(b1: B.buffer t1)
(b2: HS.mreference t2 pre)
: Lemma
(requires (B.live h b1 /\ HS.unused_in b2 h))
(ensures (loc_disjoint (loc_buffer b1) (loc_freed_mreference b2)))
[SMTPat (B.live h b1); SM... | let buffer_live_mreference_unused_in_disjoint #t1 #t2 #pre h b1 b2 =
loc_disjoint_includes (loc_freed_mreference (B.content b1)) (loc_freed_mreference b2) (loc_buffer b1) (loc_freed_mreference b2) | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 129,
"end_line": 416,
"start_col": 0,
"start_line": 415
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
b1: FStar.Buffer.buffer t1 ->
b2: FStar.Monotonic.HyperStack.mreference t2 pre
-> FStar.Pervasives.Lemma
(requires FStar.Buffer.live h b1 /\ FStar.Monotonic.HyperStack.unused_in b2 h)
(ensures
FStar.Modifies.loc_disjoint (FStar.Modifies.loc_buffer ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Modifies.loc_disjoint_includes",
"FStar.Modifies.loc_freed_mreference",
"FStar.Buffer.lseq",
"FStar.Buffer.max_length",
"FStar.Heap.trivial_preorder",
"FStar.Buffer.c... | [] | true | false | true | false | false | let buffer_live_mreference_unused_in_disjoint #t1 #t2 #pre h b1 b2 =
| loc_disjoint_includes (loc_freed_mreference (B.content b1))
(loc_freed_mreference b2)
(loc_buffer b1)
(loc_freed_mreference b2) | false |
FStar.Modifies.fst | FStar.Modifies.modifies_free | val modifies_free
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel { HS.is_mm r } )
(m: HS.mem { m `HS.contains` r } )
: Lemma
(modifies (loc_freed_mreference r) m (HS.free r m)) | val modifies_free
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel { HS.is_mm r } )
(m: HS.mem { m `HS.contains` r } )
: Lemma
(modifies (loc_freed_mreference r) m (HS.free r m)) | let modifies_free = MG.modifies_free #_ #cls | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 324,
"start_col": 0,
"start_line": 324
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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: FStar.Monotonic.HyperStack.mreference a rel {FStar.Monotonic.HyperStack.is_mm r} ->
m: FStar.Monotonic.HyperStack.mem{FStar.Monotonic.HyperStack.contains m r}
-> FStar.Pervasives.Lemma
(ensures
FStar.Modifies.modifies (FStar.Modifies.loc_freed_mreference r)
m
(FStar.Monotonic.Hyp... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_free",
"FStar.Modifies.aloc",
"FStar.Modifies.cls"
] | [] | true | false | true | false | false | let modifies_free =
| MG.modifies_free #_ #cls | false |
FStar.Modifies.fst | FStar.Modifies.modifies_buffer_none_modifies | val modifies_buffer_none_modifies
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_none h1 h2))
(ensures (modifies loc_none h1 h2)) | val modifies_buffer_none_modifies
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_none h1 h2))
(ensures (modifies loc_none h1 h2)) | let modifies_buffer_none_modifies h1 h2 =
MG.modifies_none_intro #_ #cls h1 h2
(fun _ -> ())
(fun _ _ _ -> ())
(fun _ _ -> ()) | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 332,
"start_col": 0,
"start_line": 328
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 | h1: FStar.Monotonic.HyperStack.mem -> h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.modifies_none h1 h2)
(ensures FStar.Modifies.modifies FStar.Modifies.loc_none h1 h2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_none_intro",
"FStar.Modifies.aloc",
"FStar.Modifies.cls",
"FStar.Monotonic.HyperHeap.rid",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"Prims.nat"
] | [] | false | false | true | false | false | let modifies_buffer_none_modifies h1 h2 =
| MG.modifies_none_intro #_ #cls h1 h2 (fun _ -> ()) (fun _ _ _ -> ()) (fun _ _ -> ()) | false |
FStar.Modifies.fst | FStar.Modifies.not_live_region_does_not_contain_addr | val not_live_region_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (~ (HS.live_region h (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | val not_live_region_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (~ (HS.live_region h (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | let not_live_region_does_not_contain_addr = MG.not_live_region_does_not_contain_addr | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 84,
"end_line": 420,
"start_col": 0,
"start_line": 420
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 | h: FStar.Monotonic.HyperStack.mem -> ra: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires ~(FStar.Monotonic.HyperStack.live_region h (FStar.Pervasives.Native.fst ra)))
(ensures FStar.Modifies.does_not_contain_addr h ra) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.not_live_region_does_not_contain_addr"
] | [] | true | false | true | false | false | let not_live_region_does_not_contain_addr =
| MG.not_live_region_does_not_contain_addr | false |
FStar.Modifies.fst | FStar.Modifies.region_liveness_insensitive_regions | val region_liveness_insensitive_regions (rs: Set.set HS.rid) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))] | val region_liveness_insensitive_regions (rs: Set.set HS.rid) : Lemma
(region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))
[SMTPat (region_liveness_insensitive_locs `loc_includes` (loc_regions true rs))] | let region_liveness_insensitive_regions =
MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 290,
"start_col": 0,
"start_line": 289
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 | rs: FStar.Set.set FStar.Monotonic.HyperHeap.rid
-> FStar.Pervasives.Lemma
(ensures
FStar.Modifies.loc_includes FStar.Modifies.region_liveness_insensitive_locs
(FStar.Modifies.loc_regions true rs))
[
SMTPat (FStar.Modifies.loc_includes FStar.Modifies.region_liveness_insensitive_lo... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.loc_includes_region_liveness_insensitive_locs_loc_regions",
"FStar.Modifies.aloc",
"FStar.Modifies.cls"
] | [] | true | false | true | false | false | let region_liveness_insensitive_regions =
| MG.loc_includes_region_liveness_insensitive_locs_loc_regions cls | false |
FStar.Modifies.fst | FStar.Modifies.modifies_1_modifies | val modifies_1_modifies
(#a: Type)
(b: B.buffer a)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
[SMTPat (B.modifies_1 b h1 h2)] | val modifies_1_modifies
(#a: Type)
(b: B.buffer a)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_1 b h1 h2))
(ensures (modifies (loc_buffer b) h1 h2))
[SMTPat (B.modifies_1 b h1 h2)] | let modifies_1_modifies #a b h1 h2 =
B.lemma_reveal_modifies_1 b h1 h2;
MG.modifies_intro (loc_buffer b) h1 h2
(fun _ -> ())
(fun t' pre' b' ->
MG.loc_disjoint_sym (loc_mreference b') (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_ #cls #(B.frameOf b) #(B.as_addr b) (LocBuffer b) true (HS... | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 353,
"start_col": 0,
"start_line": 341
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 -> h1: FStar.Monotonic.HyperStack.mem -> h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.modifies_1 b h1 h2)
(ensures FStar.Modifies.modifies (FStar.Modifies.loc_buffer b) h1 h2)
[SMTPat (FStar.Buffer.modifies_1 b h1 h2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_intro",
"FStar.Modifies.aloc",
"FStar.Modifies.cls",
"FStar.Modifies.loc_buffer",
"FStar.Monotonic.HyperHeap.rid",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Modifie... | [] | false | false | true | false | false | let modifies_1_modifies #a b h1 h2 =
| B.lemma_reveal_modifies_1 b h1 h2;
MG.modifies_intro (loc_buffer b)
h1
h2
(fun _ -> ())
(fun t' pre' b' ->
MG.loc_disjoint_sym (loc_mreference b') (loc_buffer b);
MG.loc_disjoint_aloc_addresses_elim #_
#cls
#(B.frameOf b)
#(B.as_addr b)
(LocBuffer b)
true
... | false |
FStar.Modifies.fst | FStar.Modifies.unused_in_does_not_contain_addr | val unused_in_does_not_contain_addr
(h: HS.mem)
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
: Lemma
(requires (r `HS.unused_in` h))
(ensures (h `does_not_contain_addr` (HS.frameOf r, HS.as_addr r))) | val unused_in_does_not_contain_addr
(h: HS.mem)
(#a: Type)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
: Lemma
(requires (r `HS.unused_in` h))
(ensures (h `does_not_contain_addr` (HS.frameOf r, HS.as_addr r))) | let unused_in_does_not_contain_addr = MG.unused_in_does_not_contain_addr | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 422,
"start_col": 0,
"start_line": 422
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 | h: FStar.Monotonic.HyperStack.mem -> r: FStar.Monotonic.HyperStack.mreference a rel
-> FStar.Pervasives.Lemma (requires FStar.Monotonic.HyperStack.unused_in r h)
(ensures
FStar.Modifies.does_not_contain_addr h
(FStar.Monotonic.HyperStack.frameOf r,
FStar.Monotonic.HyperStack.as_addr ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.unused_in_does_not_contain_addr"
] | [] | true | false | true | false | false | let unused_in_does_not_contain_addr =
| MG.unused_in_does_not_contain_addr | false |
FStar.Modifies.fst | FStar.Modifies.mreference_live_buffer_unused_in_disjoint | val mreference_live_buffer_unused_in_disjoint
(#t1: Type)
(#pre: Preorder.preorder t1)
(#t2: Type)
(h: HS.mem)
(b1: HS.mreference t1 pre)
(b2: B.buffer t2)
: Lemma
(requires (HS.contains h b1 /\ B.unused_in b2 h))
(ensures (loc_disjoint (loc_freed_mreference b1) (loc_buffer b2)))
[SMTPat (HS.contains... | val mreference_live_buffer_unused_in_disjoint
(#t1: Type)
(#pre: Preorder.preorder t1)
(#t2: Type)
(h: HS.mem)
(b1: HS.mreference t1 pre)
(b2: B.buffer t2)
: Lemma
(requires (HS.contains h b1 /\ B.unused_in b2 h))
(ensures (loc_disjoint (loc_freed_mreference b1) (loc_buffer b2)))
[SMTPat (HS.contains... | let mreference_live_buffer_unused_in_disjoint #t1 #pre #t2 h b1 b2 =
loc_disjoint_includes (loc_freed_mreference b1) (loc_freed_mreference (B.content b2)) (loc_freed_mreference b1) (loc_buffer b2) | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 129,
"end_line": 413,
"start_col": 0,
"start_line": 412
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 |
h: FStar.Monotonic.HyperStack.mem ->
b1: FStar.Monotonic.HyperStack.mreference t1 pre ->
b2: FStar.Buffer.buffer t2
-> FStar.Pervasives.Lemma
(requires FStar.Monotonic.HyperStack.contains h b1 /\ FStar.Buffer.unused_in b2 h)
(ensures
FStar.Modifies.loc_disjoint (FStar.Modifies.loc_fre... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.HyperStack.mreference",
"FStar.Buffer.buffer",
"FStar.Modifies.loc_disjoint_includes",
"FStar.Modifies.loc_freed_mreference",
"FStar.Buffer.lseq",
"FStar.Buffer.max_length",
"FStar.Heap.trivial_preorder",
"FStar.Buffer.c... | [] | true | false | true | false | false | let mreference_live_buffer_unused_in_disjoint #t1 #pre #t2 h b1 b2 =
| loc_disjoint_includes (loc_freed_mreference b1)
(loc_freed_mreference (B.content b2))
(loc_freed_mreference b1)
(loc_buffer b2) | false |
FStar.Modifies.fst | FStar.Modifies.does_not_contain_addr_elim | val does_not_contain_addr_elim
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
m `does_not_contain_addr` x /\
HS.frameOf r == fst x /\
HS.as_addr r == snd x
))
(ensures (~ (m `HS.contains` r))) | val does_not_contain_addr_elim
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
m `does_not_contain_addr` x /\
HS.frameOf r == fst x /\
HS.as_addr r == snd x
))
(ensures (~ (m `HS.contains` r))) | let does_not_contain_addr_elim = MG.does_not_contain_addr_elim | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 428,
"start_col": 0,
"start_line": 428
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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: FStar.Monotonic.HyperStack.mreference a rel ->
m: FStar.Monotonic.HyperStack.mem ->
x: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
FStar.Modifies.does_not_contain_addr m x /\
FStar.Monotonic.HyperStack.frameOf r == FStar.Pervasives.Native.fst x... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.does_not_contain_addr_elim"
] | [] | true | false | true | false | false | let does_not_contain_addr_elim =
| MG.does_not_contain_addr_elim | false |
FStar.Modifies.fst | FStar.Modifies.free_does_not_contain_addr | val free_does_not_contain_addr
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
HS.is_mm r /\
m `HS.contains` r /\
fst x == HS.frameOf r /\
snd x == HS.as_addr r
))
(ensures (
HS.free r m `does_not_contain_addr` x
))... | val free_does_not_contain_addr
(#a: Type0)
(#rel: Preorder.preorder a)
(r: HS.mreference a rel)
(m: HS.mem)
(x: HS.rid * nat)
: Lemma
(requires (
HS.is_mm r /\
m `HS.contains` r /\
fst x == HS.frameOf r /\
snd x == HS.as_addr r
))
(ensures (
HS.free r m `does_not_contain_addr` x
))... | let free_does_not_contain_addr = MG.free_does_not_contain_addr | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 426,
"start_col": 0,
"start_line": 426
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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: FStar.Monotonic.HyperStack.mreference a rel ->
m: FStar.Monotonic.HyperStack.mem ->
x: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.is_mm r /\ FStar.Monotonic.HyperStack.contains m r /\
FStar.Pervasives.Native.fst x ==... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.free_does_not_contain_addr"
] | [] | true | false | true | false | false | let free_does_not_contain_addr =
| MG.free_does_not_contain_addr | false |
FStar.Modifies.fst | FStar.Modifies.addr_unused_in_does_not_contain_addr | val addr_unused_in_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (HS.live_region h (fst ra) ==> snd ra `Heap.addr_unused_in` (Map.sel (HS.get_hmap h) (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | val addr_unused_in_does_not_contain_addr
(h: HS.mem)
(ra: HS.rid * nat)
: Lemma
(requires (HS.live_region h (fst ra) ==> snd ra `Heap.addr_unused_in` (Map.sel (HS.get_hmap h) (fst ra))))
(ensures (h `does_not_contain_addr` ra)) | let addr_unused_in_does_not_contain_addr = MG.addr_unused_in_does_not_contain_addr | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 424,
"start_col": 0,
"start_line": 424
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 | h: FStar.Monotonic.HyperStack.mem -> ra: (FStar.Monotonic.HyperHeap.rid * Prims.nat)
-> FStar.Pervasives.Lemma
(requires
FStar.Monotonic.HyperStack.live_region h (FStar.Pervasives.Native.fst ra) ==>
FStar.Monotonic.Heap.addr_unused_in (FStar.Pervasives.Native.snd ra)
(FStar.Map.sel (FS... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.addr_unused_in_does_not_contain_addr"
] | [] | true | false | true | false | false | let addr_unused_in_does_not_contain_addr =
| MG.addr_unused_in_does_not_contain_addr | false |
FStar.Modifies.fst | FStar.Modifies.modifies_only_live_addresses | val modifies_only_live_addresses
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_addresses false r a) l) h h' /\
(forall x . Set.mem x a ==> h `does_not_contain_addr` (r, x))
))
(ensures (modifies l h h')) | val modifies_only_live_addresses
(r: HS.rid)
(a: Set.set nat)
(l: loc)
(h h' : HS.mem)
: Lemma
(requires (
modifies (loc_union (loc_addresses false r a) l) h h' /\
(forall x . Set.mem x a ==> h `does_not_contain_addr` (r, x))
))
(ensures (modifies l h h')) | let modifies_only_live_addresses = MG.modifies_only_live_addresses | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 66,
"end_line": 430,
"start_col": 0,
"start_line": 430
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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: FStar.Monotonic.HyperHeap.rid ->
a: FStar.Set.set Prims.nat ->
l: FStar.Modifies.loc ->
h: FStar.Monotonic.HyperStack.mem ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
FStar.Modifies.modifies (FStar.Modifies.loc_union (FStar.Modifies.loc_addresses fals... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.ModifiesGen.modifies_only_live_addresses",
"FStar.Modifies.aloc",
"FStar.Modifies.cls"
] | [] | true | false | true | false | false | let modifies_only_live_addresses =
| MG.modifies_only_live_addresses | false |
FStar.Modifies.fst | FStar.Modifies.modifies_2_modifies | val modifies_2_modifies
(#a1 #a2: Type)
(b1: B.buffer a1)
(b2: B.buffer a2)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_2 b1 b2 h1 h2))
(ensures (modifies (loc_union (loc_buffer b1) (loc_buffer b2)) h1 h2))
[SMTPat (B.modifies_2 b1 b2 h1 h2)] | val modifies_2_modifies
(#a1 #a2: Type)
(b1: B.buffer a1)
(b2: B.buffer a2)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_2 b1 b2 h1 h2))
(ensures (modifies (loc_union (loc_buffer b1) (loc_buffer b2)) h1 h2))
[SMTPat (B.modifies_2 b1 b2 h1 h2)] | let modifies_2_modifies #a1 #a2 b1 b2 h1 h2 =
B.lemma_reveal_modifies_2 b1 b2 h1 h2;
MG.modifies_intro (loc_union (loc_buffer b1) (loc_buffer b2)) h1 h2
(fun _ -> ())
(fun t' pre' b' ->
loc_disjoint_includes (loc_mreference b') (loc_union (loc_buffer b1) (loc_buffer b2)) (loc_mreference b') (loc_buffe... | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 374,
"start_col": 0,
"start_line": 355
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 a1 ->
b2: FStar.Buffer.buffer a2 ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.modifies_2 b1 b2 h1 h2)
(ensures
FStar.Modifies.modifies (FStar.Modifies.loc_union (FStar.Modifies.loc_bu... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_intro",
"FStar.Modifies.aloc",
"FStar.Modifies.cls",
"FStar.Modifies.loc_union",
"FStar.Modifies.loc_buffer",
"FStar.Monotonic.HyperHeap.rid",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack... | [] | false | false | true | false | false | let modifies_2_modifies #a1 #a2 b1 b2 h1 h2 =
| B.lemma_reveal_modifies_2 b1 b2 h1 h2;
MG.modifies_intro (loc_union (loc_buffer b1) (loc_buffer b2))
h1
h2
(fun _ -> ())
(fun t' pre' b' ->
loc_disjoint_includes (loc_mreference b')
(loc_union (loc_buffer b1) (loc_buffer b2))
(loc_mreference b')
(loc_buffer b1);
loc_disjoint_... | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.get | val get: Prims.unit -> rand store | val get: Prims.unit -> rand store | let get () : rand store = fun s -> Some s, fst s | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 48,
"end_line": 36,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> FStar.DM4F.OTP.Random.rand FStar.DM4F.OTP.Random.store | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.DM4F.OTP.Random.store",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.fst",
"FStar.DM4F.OTP.Random.rand"
] | [] | false | false | false | true | false | let get () : rand store =
| fun s -> Some s, fst s | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.return | val return (a: Type) (x: a) : rand a | val return (a: Type) (x: a) : rand a | let return (a:Type) (x:a) : rand a = fun (next,_) -> Some x, next | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 26,
"start_col": 0,
"start_line": 26
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> x: a -> FStar.DM4F.OTP.Random.rand a | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"FStar.DM4F.OTP.Random.rand"
] | [] | false | false | false | true | false | let return (a: Type) (x: a) : rand a =
| fun (next, _) -> Some x, next | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.raise | val raise: a: Type -> Prims.unit -> rand a | val raise: a: Type -> Prims.unit -> rand a | let raise (a:Type) () : rand a = fun s -> None, fst s | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 42,
"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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> _: Prims.unit -> FStar.DM4F.OTP.Random.rand a | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.fst",
"FStar.DM4F.OTP.Random.rand"
] | [] | false | false | false | true | false | let raise (a: Type) () : rand a =
| fun s -> None, fst s | false |
FStar.Modifies.fst | FStar.Modifies.modifies_3_modifies | val modifies_3_modifies
(#a1 #a2 #a3: Type)
(b1: B.buffer a1)
(b2: B.buffer a2)
(b3: B.buffer a3)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_3 b1 b2 b3 h1 h2))
(ensures (modifies (loc_union (loc_buffer b1) (loc_union (loc_buffer b2) (loc_buffer b3))) h1 h2)) | val modifies_3_modifies
(#a1 #a2 #a3: Type)
(b1: B.buffer a1)
(b2: B.buffer a2)
(b3: B.buffer a3)
(h1 h2: HS.mem)
: Lemma
(requires (B.modifies_3 b1 b2 b3 h1 h2))
(ensures (modifies (loc_union (loc_buffer b1) (loc_union (loc_buffer b2) (loc_buffer b3))) h1 h2)) | let modifies_3_modifies #a1 #a2 #a3 b1 b2 b3 h1 h2 =
B.lemma_reveal_modifies_3 b1 b2 b3 h1 h2;
MG.modifies_intro (loc_union (loc_buffer b1) (loc_union (loc_buffer b2) (loc_buffer b3))) h1 h2
(fun _ -> ())
(fun t' pre' b' ->
loc_disjoint_includes (loc_mreference b') (loc_union (loc_buffer b1) (loc_unio... | {
"file_name": "ulib/FStar.Modifies.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 402,
"start_col": 0,
"start_line": 378
} | (*
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.Set.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.ModifiesGen.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.ModifiesGen",
"short_module": "MG"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FS... | {
"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 a1 ->
b2: FStar.Buffer.buffer a2 ->
b3: FStar.Buffer.buffer a3 ->
h1: FStar.Monotonic.HyperStack.mem ->
h2: FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma (requires FStar.Buffer.modifies_3 b1 b2 b3 h1 h2)
(ensures
FStar.Modifies.modifies (FStar.Modi... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Buffer.buffer",
"FStar.Monotonic.HyperStack.mem",
"FStar.ModifiesGen.modifies_intro",
"FStar.Modifies.aloc",
"FStar.Modifies.cls",
"FStar.Modifies.loc_union",
"FStar.Modifies.loc_buffer",
"FStar.Monotonic.HyperHeap.rid",
"Prims.unit",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack... | [] | false | false | true | false | false | let modifies_3_modifies #a1 #a2 #a3 b1 b2 b3 h1 h2 =
| B.lemma_reveal_modifies_3 b1 b2 b3 h1 h2;
MG.modifies_intro (loc_union (loc_buffer b1) (loc_union (loc_buffer b2) (loc_buffer b3)))
h1
h2
(fun _ -> ())
(fun t' pre' b' ->
loc_disjoint_includes (loc_mreference b')
(loc_union (loc_buffer b1) (loc_union (loc_buffer b2) (loc_buffer b3)))
(loc_... | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.bind | val bind (a b: Type) (c: rand a) (f: (a -> rand b)) : rand b | val bind (a b: Type) (c: rand a) (f: (a -> rand b)) : rand b | let bind (a b:Type) (c:rand a) (f:a -> rand b) : rand b =
fun s ->
let r, next = c s in
match r with
| None -> None, next
| Some x -> f x (next, snd s) | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 33,
"start_col": 0,
"start_line": 28
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> b: Type -> c: FStar.DM4F.OTP.Random.rand a -> f: (_: a -> FStar.DM4F.OTP.Random.rand b)
-> FStar.DM4F.OTP.Random.rand b | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.OTP.Random.rand",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.snd"
] | [] | false | false | false | true | false | let bind (a b: Type) (c: rand a) (f: (a -> rand b)) : rand b =
| fun s ->
let r, next = c s in
match r with
| None -> None, next
| Some x -> f x (next, snd s) | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.test_sample_none | val test_sample_none : v: FStar.DM4F.OTP.Heap.elem ->
t:
FStar.DM4F.OTP.Heap.tape
{Prims.op_Negation (FStar.DM4F.OTP.Heap.incrementable (FStar.DM4F.OTP.Heap.to_id 9))}
-> Prims.unit | let test_sample_none (v:elem) (t:tape { not (incrementable (to_id 9)) } ) =
let f = reify (sample ()) in
assert (f (to_id 9,t) == (None, to_id 9)) | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 84,
"start_col": 0,
"start_line": 82
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
v: FStar.DM4F.OTP.Heap.elem ->
t:
FStar.DM4F.OTP.Heap.tape
{Prims.op_Negation (FStar.DM4F.OTP.Heap.incrementable (FStar.DM4F.OTP.Heap.to_id 9))}
-> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.OTP.Heap.elem",
"FStar.DM4F.OTP.Heap.tape",
"Prims.b2t",
"Prims.op_Negation",
"FStar.DM4F.OTP.Heap.incrementable",
"FStar.DM4F.OTP.Heap.to_id",
"Prims._assert",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.option",
"FStar.DM4F.OTP.Heap.id",
"FStar.Pervasi... | [] | false | false | false | false | false | let test_sample_none (v: elem) (t: tape{not (incrementable (to_id 9))}) =
| let f = reify (sample ()) in
assert (f (to_id 9, t) == (None, to_id 9)) | false | |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.point | val point: #a:eqtype -> x:a -> y:option a -> nat | val point: #a:eqtype -> x:a -> y:option a -> nat | let point #a x = fun y -> if y = Some x then 1 else 0 | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 128,
"start_col": 0,
"start_line": 128
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> y: FStar.Pervasives.Native.option a -> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"FStar.Pervasives.Native.option",
"Prims.op_Equality",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"Prims.nat"
] | [] | false | false | false | false | false | let point #a x =
| fun y -> if y = Some x then 1 else 0 | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.sum_extensional | val sum_extensional: f:(tape -> nat) -> g:(tape -> nat) -> Lemma
(requires (forall h. f h == g h))
(ensures (sum f == sum g)) | val sum_extensional: f:(tape -> nat) -> g:(tape -> nat) -> Lemma
(requires (forall h. f h == g h))
(ensures (sum f == sum g)) | let sum_extensional f g =
sum_monotonic f g;
sum_monotonic g f | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 116,
"start_col": 0,
"start_line": 114
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: FStar.DM4F.OTP.Heap.tape -> Prims.nat) -> g: (_: FStar.DM4F.OTP.Heap.tape -> Prims.nat)
-> FStar.Pervasives.Lemma (requires forall (h: FStar.DM4F.OTP.Heap.tape). f h == g h)
(ensures FStar.DM4F.OTP.Random.sum f == FStar.DM4F.OTP.Random.sum g) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.DM4F.OTP.Heap.tape",
"Prims.nat",
"FStar.DM4F.OTP.Random.sum_monotonic",
"Prims.unit"
] | [] | true | false | true | false | false | let sum_extensional f g =
| sum_monotonic f g;
sum_monotonic g f | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.inverse | val inverse (bij: bijection) : bijection | val inverse (bij: bijection) : bijection | let inverse (bij:bijection) : bijection =
Bijection bij.finv bij.f | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 95,
"start_col": 0,
"start_line": 94
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | bij: FStar.DM4F.OTP.Random.bijection -> FStar.DM4F.OTP.Random.bijection | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.OTP.Random.bijection",
"FStar.DM4F.OTP.Random.Bijection",
"FStar.DM4F.OTP.Random.__proj__Bijection__item__finv",
"FStar.DM4F.OTP.Random.__proj__Bijection__item__f"
] | [] | false | false | false | true | false | let inverse (bij: bijection) : bijection =
| Bijection bij.finv bij.f | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.mass | val mass: #a:Type -> f:(store -> M (a * id)) -> p:(a -> nat) -> nat | val mass: #a:Type -> f:(store -> M (a * id)) -> p:(a -> nat) -> nat | let mass #a f p = sum (fun h -> let r,_ = f (to_id 0,h) in p r) | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 63,
"end_line": 125,
"start_col": 0,
"start_line": 125
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
f: (_: FStar.DM4F.OTP.Random.store -> Prims.M (a * FStar.DM4F.OTP.Heap.id)) ->
p: (_: a -> Prims.nat)
-> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.OTP.Random.store",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"Prims.nat",
"FStar.DM4F.OTP.Random.sum",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.Mktuple2",
"FStar.DM4F.OTP.Heap.to_id"
] | [] | false | false | false | true | false | let mass #a f p =
| sum (fun h ->
let r, _ = f (to_id 0, h) in
p r) | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.test_sample_some | val test_sample_some : v: FStar.DM4F.OTP.Heap.elem ->
t:
FStar.DM4F.OTP.Heap.tape
{ FStar.DM4F.OTP.Heap.sel t (FStar.DM4F.OTP.Heap.to_id 0) == v /\
FStar.DM4F.OTP.Heap.incrementable (FStar.DM4F.OTP.Heap.to_id 0) /\
FStar.DM4F.OTP.Heap.incr (FStar.DM4F.OTP.Heap.to_id 0) == FStar.DM4... | let test_sample_some (v:elem) (t:tape{
sel t (to_id 0) == v /\
incrementable (to_id 0) /\
incr (to_id 0) == to_id 1
}) =
let f = reify (sample()) in
assert (f (to_id 0,t) == (Some v, to_id 1)) | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 79,
"start_col": 0,
"start_line": 73
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
v: FStar.DM4F.OTP.Heap.elem ->
t:
FStar.DM4F.OTP.Heap.tape
{ FStar.DM4F.OTP.Heap.sel t (FStar.DM4F.OTP.Heap.to_id 0) == v /\
FStar.DM4F.OTP.Heap.incrementable (FStar.DM4F.OTP.Heap.to_id 0) /\
FStar.DM4F.OTP.Heap.incr (FStar.DM4F.OTP.Heap.to_id 0) == FStar.DM4F.OTP.Heap.to_id 1... | Prims.Tot | [
"total"
] | [] | [
"FStar.DM4F.OTP.Heap.elem",
"FStar.DM4F.OTP.Heap.tape",
"Prims.l_and",
"Prims.eq2",
"FStar.DM4F.OTP.Heap.sel",
"FStar.DM4F.OTP.Heap.to_id",
"Prims.b2t",
"FStar.DM4F.OTP.Heap.incrementable",
"FStar.DM4F.OTP.Heap.id",
"FStar.DM4F.OTP.Heap.incr",
"Prims._assert",
"FStar.Pervasives.Native.tuple2",... | [] | false | false | false | false | false | let test_sample_some
(v: elem)
(t: tape{sel t (to_id 0) == v /\ incrementable (to_id 0) /\ incr (to_id 0) == to_id 1})
=
| let f = reify (sample ()) in
assert (f (to_id 0, t) == (Some v, to_id 1)) | false | |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.pr_leq | val pr_leq: #a:Type -> #b:Type ->
c1:(store -> M (a * id)) ->
c2:(store -> M (b * id)) ->
p1:(a -> nat) ->
p2:(b -> nat) ->
bij:bijection -> Lemma
(requires
(forall t.
let r1,_ = c1 (to_id 0,t) in
let r2,_ = c2 (to_id 0,bij.f t) in
p1 r1 <= p2 r2))
(ensures (mass c1 p1 <= mass c2 p2)... | val pr_leq: #a:Type -> #b:Type ->
c1:(store -> M (a * id)) ->
c2:(store -> M (b * id)) ->
p1:(a -> nat) ->
p2:(b -> nat) ->
bij:bijection -> Lemma
(requires
(forall t.
let r1,_ = c1 (to_id 0,t) in
let r2,_ = c2 (to_id 0,bij.f t) in
p1 r1 <= p2 r2))
(ensures (mass c1 p1 <= mass c2 p2)... | let pr_leq #a #b c1 c2 p1 p2 bij =
let bij' = inverse bij in
let f1 = (fun h -> let r1,_ = c1 (to_id 0,h) in p1 r1) in
let f2 = (fun h -> let r2,_ = c2 (to_id 0,h) in p2 r2) in
sum_monotonic f1 (fun h -> let r2,_ = c2 (to_id 0,bij.f h) in p2 r2);
sum_bijection (fun h -> let r2,_ = c2 (to_id 0,bij.f h) in p2 r... | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 81,
"end_line": 153,
"start_col": 0,
"start_line": 147
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c1: (_: FStar.DM4F.OTP.Random.store -> Prims.M (a * FStar.DM4F.OTP.Heap.id)) ->
c2: (_: FStar.DM4F.OTP.Random.store -> Prims.M (b * FStar.DM4F.OTP.Heap.id)) ->
p1: (_: a -> Prims.nat) ->
p2: (_: b -> Prims.nat) ->
bij: FStar.DM4F.OTP.Random.bijection
-> FStar.Pervasives.Lemma
(requires
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.DM4F.OTP.Random.store",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"Prims.nat",
"FStar.DM4F.OTP.Random.bijection",
"FStar.DM4F.OTP.Random.sum_extensional",
"FStar.DM4F.OTP.Heap.tape",
"FStar.Pervasives.Native.Mktuple2",
"FStar.DM4F.OTP.Heap.to_id",
"FStar.DM4F.OTP.Random.__... | [] | false | false | true | false | false | let pr_leq #a #b c1 c2 p1 p2 bij =
| let bij' = inverse bij in
let f1 =
(fun h ->
let r1, _ = c1 (to_id 0, h) in
p1 r1)
in
let f2 =
(fun h ->
let r2, _ = c2 (to_id 0, h) in
p2 r2)
in
sum_monotonic f1
(fun h ->
let r2, _ = c2 (to_id 0, bij.f h) in
p2 r2);
sum_bijection (fun h ->
let r2, _ = c2 (to_id 0, bij.f... | false |
FStar.DM4F.OTP.Random.fst | FStar.DM4F.OTP.Random.pr_eq | val pr_eq: #a:Type -> #b:Type ->
c1:(store -> M (a * id)) ->
c2:(store -> M (b * id)) ->
p1:(a -> nat) ->
p2:(b -> nat) ->
bij:bijection -> Lemma
(requires
(forall h. let r1,_ = c1 (to_id 0, h) in
let r2,_ = c2 (to_id 0, bij.f h) in
p1 r1 == p2 r2))
(ensures (mass c1 p1 == mass c2 ... | val pr_eq: #a:Type -> #b:Type ->
c1:(store -> M (a * id)) ->
c2:(store -> M (b * id)) ->
p1:(a -> nat) ->
p2:(b -> nat) ->
bij:bijection -> Lemma
(requires
(forall h. let r1,_ = c1 (to_id 0, h) in
let r2,_ = c2 (to_id 0, bij.f h) in
p1 r1 == p2 r2))
(ensures (mass c1 p1 == mass c2 ... | let pr_eq #a #b c1 c2 p1 p2 bij =
pr_leq c1 c2 p1 p2 bij;
pr_leq c2 c1 p2 p1 (inverse bij) | {
"file_name": "examples/dm4free/FStar.DM4F.OTP.Random.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 170,
"start_col": 0,
"start_line": 168
} | (*
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.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.DM4F.OTP.Heap.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.DM4F.OTP.Random.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.DM4F.OTP",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
c1: (_: FStar.DM4F.OTP.Random.store -> Prims.M (a * FStar.DM4F.OTP.Heap.id)) ->
c2: (_: FStar.DM4F.OTP.Random.store -> Prims.M (b * FStar.DM4F.OTP.Heap.id)) ->
p1: (_: a -> Prims.nat) ->
p2: (_: b -> Prims.nat) ->
bij: FStar.DM4F.OTP.Random.bijection
-> FStar.Pervasives.Lemma
(requires
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.DM4F.OTP.Random.store",
"FStar.Pervasives.Native.tuple2",
"FStar.DM4F.OTP.Heap.id",
"Prims.nat",
"FStar.DM4F.OTP.Random.bijection",
"FStar.DM4F.OTP.Random.pr_leq",
"FStar.DM4F.OTP.Random.inverse",
"Prims.unit"
] | [] | true | false | true | false | false | let pr_eq #a #b c1 c2 p1 p2 bij =
| pr_leq c1 c2 p1 p2 bij;
pr_leq c2 c1 p2 p1 (inverse bij) | false |
Spec.Frodo.Lemmas.fst | Spec.Frodo.Lemmas.lemma_frodo_sample2 | val lemma_frodo_sample2:
sign:uint16{v sign <= 1} -> e:uint16 -> Lemma
(((lognot sign +. u16 1) ^. e) +. sign == u16 ((Math.Lib.powx (-1) (v sign) * v e) % modulus U16)) | val lemma_frodo_sample2:
sign:uint16{v sign <= 1} -> e:uint16 -> Lemma
(((lognot sign +. u16 1) ^. e) +. sign == u16 ((Math.Lib.powx (-1) (v sign) * v e) % modulus U16)) | let lemma_frodo_sample2 sign e =
calc (==) {
v ((lognot sign +. u16 1) ^. e);
(==) { logxor_spec (lognot sign +. u16 1) e }
logxor_v #U16 (v (lognot sign +. u16 1)) (v e);
(==) { lognot_plus_one sign }
logxor_v #U16 ((modulus U16 - v sign) % modulus U16) (v e);
(==) { UInt.logxor_commutative #... | {
"file_name": "specs/frodo/Spec.Frodo.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 47,
"end_line": 100,
"start_col": 0,
"start_line": 65
} | module Spec.Frodo.Lemmas
open FStar.Mul
open Lib.IntTypes
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_mask_cast:
mask:uint16{v mask = 0 \/ v mask = v (ones U16 SEC)} -> Lemma
((v mask = 0 ==> v (to_u8 mask) = 0) /\
(v mask = v (ones U16 SEC) ==> v (to_u8 mask) = v (ones U8 SEC)))
let lemma_mask... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.... | [
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Frodo",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Fro... | {
"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 | sign: Lib.IntTypes.uint16{Lib.IntTypes.v sign <= 1} -> e: Lib.IntTypes.uint16
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntTypes.lognot sign +. Lib.IntTypes.u16 1 ^. e) +. sign ==
Lib.IntTypes.u16 (FStar.Math.Lib.powx (- 1) (Lib.IntTypes.v sign) * Lib.IntTypes.v e %
Lib.IntTypes.modulus Lib.In... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.uint16",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U16",
"Lib.IntTypes.SEC",
"Prims.op_Equality",
"Prims.int",
"FStar.Math.Lemmas.small_mod",
"Lib.IntTypes.modulus",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"FStar.Math.Lib.powx",
"Prims.op_... | [] | false | false | true | false | false | let lemma_frodo_sample2 sign e =
| calc ( == ) {
v ((lognot sign +. u16 1) ^. e);
( == ) { logxor_spec (lognot sign +. u16 1) e }
logxor_v #U16 (v (lognot sign +. u16 1)) (v e);
( == ) { lognot_plus_one sign }
logxor_v #U16 ((modulus U16 - v sign) % modulus U16) (v e);
( == ) { UInt.logxor_commutative #16 ((modulus U16 - v sign) % modulus U1... | false |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_load_mem_get128 | val lemma_load_mem_get128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures load_mem128 ptr (get_vale_heap h) == get_heap_val128 ptr (heap_get (coerce h)))
[SMTPat (load_mem128 ptr (get_vale_heap h))] | val lemma_load_mem_get128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures load_mem128 ptr (get_vale_heap h) == get_heap_val128 ptr (heap_get (coerce h)))
[SMTPat (load_mem128 ptr (get_vale_heap h))] | let lemma_load_mem_get128 h ptr =
MS.equiv_load_mem128 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 37,
"start_col": 0,
"start_line": 34
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.X64.Memory.valid_mem128 ptr (Vale.X64.Memory.get_vale_heap h))
(ensures
Vale.X64.Memory.load_mem128 ptr (Vale.X64.Memory.get_vale_heap h) ==
Vale.Arch.MachineHeap_s.get_heap_val128 ptr
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.X64.Memory_Sems.lemma_heap_get_heap",
"Vale.X64.Memory_Sems.equiv_load_mem128",
"Vale.X64.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_load_mem_get128 h ptr =
| MS.equiv_load_mem128 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | false |
Hacl.Spec.Bignum.MontArithmetic.fsti | Hacl.Spec.Bignum.MontArithmetic.bn_mont_nat | val bn_mont_nat : k: Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t -> Type0 | let bn_mont_nat (#t:limb_t) (k:bn_mont_ctx t) =
x:lbignum t k.len{bn_v x < bn_v k.n} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | module Hacl.Spec.Bignum.MontArithmetic
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module Euclid = FStar.Math.Euclid
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_mont_ctx_pre (#t:limb_t) (#len:BN... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Tactics.Ty... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": false,... | {
"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 | k: Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__len",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.MontArithmetic.__pr... | [] | false | false | false | false | true | let bn_mont_nat (#t: limb_t) (k: bn_mont_ctx t) =
| x: lbignum t k.len {bn_v x < bn_v k.n} | false | |
Hacl.Spec.Bignum.MontArithmetic.fsti | Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx_pre | val bn_mont_ctx_pre : n: Hacl.Spec.Bignum.Definitions.lbignum t len -> Prims.logical | let bn_mont_ctx_pre (#t:limb_t) (#len:BN.bn_len t) (n:lbignum t len) =
1 < bn_v n /\ bn_v n % 2 = 1 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 17,
"start_col": 0,
"start_line": 16
} | module Hacl.Spec.Bignum.MontArithmetic
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module Euclid = FStar.Math.Euclid
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Tactics.Ty... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": false,... | {
"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 | n: Hacl.Spec.Bignum.Definitions.lbignum t len -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.bn_len",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.logical"
] | [] | false | false | false | false | true | let bn_mont_ctx_pre (#t: limb_t) (#len: BN.bn_len t) (n: lbignum t len) =
| 1 < bn_v n /\ bn_v n % 2 = 1 | false | |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_to_of | val lemma_to_of (s:machine_state) : Lemma
(ensures state_to_S (state_of_S s) == {s with Ms.ms_trace = []}) | val lemma_to_of (s:machine_state) : Lemma
(ensures state_to_S (state_of_S s) == {s with Ms.ms_trace = []}) | let lemma_to_of s =
let open Ms in
let s' = state_of_S s in
let s'' = state_to_S s' in
assert (feq s.ms_regs s''.ms_regs);
assert (feq s.ms_flags s''.ms_flags);
VSS.lemma_stack_to_from s.ms_stack;
() | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 80,
"start_col": 0,
"start_line": 73
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 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 | s: Vale.X64.StateLemmas.machine_state
-> FStar.Pervasives.Lemma
(ensures
Vale.X64.StateLemmas.state_to_S (Vale.X64.StateLemmas.state_of_S s) ==
Vale.X64.Machine_Semantics_s.Mkmachine_state (Mkmachine_state?.ms_ok s)
(Mkmachine_state?.ms_regs s)
(Mkmachine_state?.ms_flags s)
(Mk... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.X64.StateLemmas.machine_state",
"Prims.unit",
"Vale.X64.Stack_Sems.lemma_stack_to_from",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Prims._assert",
"FStar.FunctionalExtensionality.feq",
"Vale.X64.Machine_s.flag",
"Vale.X64.Machine_Semantics_s.flag_val_t",
"Vale.X6... | [] | false | false | true | false | false | let lemma_to_of s =
| let open Ms in
let s' = state_of_S s in
let s'' = state_to_S s' in
assert (feq s.ms_regs s''.ms_regs);
assert (feq s.ms_flags s''.ms_flags);
VSS.lemma_stack_to_from s.ms_stack;
() | false |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_valid_mem_addr128 | val lemma_valid_mem_addr128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures valid_addr128 ptr (heap_get (coerce h)))
[SMTPat (valid_mem128 ptr (get_vale_heap h))] | val lemma_valid_mem_addr128 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem128 ptr (get_vale_heap h))
(ensures valid_addr128 ptr (heap_get (coerce h)))
[SMTPat (valid_mem128 ptr (get_vale_heap h))] | let lemma_valid_mem_addr128 h ptr =
MS.bytes_valid128 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 27,
"start_col": 0,
"start_line": 24
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.X64.Memory.valid_mem128 ptr (Vale.X64.Memory.get_vale_heap h))
(ensures
Vale.Arch.MachineHeap_s.valid_addr128 ptr
(Vale.Arch.Heap.heap_get (Vale.X64.StateLemmas.coerce h)))
[SMTPat (Vale... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.X64.Memory_Sems.lemma_heap_get_heap",
"Vale.X64.Memory_Sems.bytes_valid128",
"Vale.X64.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_valid_mem_addr128 h ptr =
| MS.bytes_valid128 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | false |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_valid_mem_addr64 | val lemma_valid_mem_addr64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures valid_addr64 ptr (heap_get (coerce h)))
[SMTPat (valid_mem64 ptr (get_vale_heap h))] | val lemma_valid_mem_addr64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures valid_addr64 ptr (heap_get (coerce h)))
[SMTPat (valid_mem64 ptr (get_vale_heap h))] | let lemma_valid_mem_addr64 h ptr =
MS.bytes_valid64 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.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": 19
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.X64.Memory.valid_mem64 ptr (Vale.X64.Memory.get_vale_heap h))
(ensures
Vale.Arch.MachineHeap_s.valid_addr64 ptr
(Vale.Arch.Heap.heap_get (Vale.X64.StateLemmas.coerce h)))
[SMTPat (Vale.X... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.X64.Memory_Sems.lemma_heap_get_heap",
"Vale.X64.Memory_Sems.bytes_valid64",
"Vale.X64.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_valid_mem_addr64 h ptr =
| MS.bytes_valid64 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | false |
Hacl.Spec.Bignum.MontArithmetic.fsti | Hacl.Spec.Bignum.MontArithmetic.bn_field_exp_st | val bn_field_exp_st : t: Hacl.Spec.Bignum.Definitions.limb_t ->
k:
Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t
{Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx_inv k}
-> Type0 | let bn_field_exp_st (t:limb_t) (k:bn_mont_ctx t{bn_mont_ctx_inv k}) =
aM:bn_mont_nat k
-> bBits:size_nat
-> b:lbignum t (blocks0 bBits (bits t)) ->
Pure (bn_mont_nat k)
(requires bn_v b < pow2 bBits)
(ensures fun cM ->
bn_v (bn_from_field k cM) == Lib.NatMod.pow_mod #(bn_v k.n) (bn_v (bn_from_field k... | {
"file_name": "code/bignum/Hacl.Spec.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 101,
"end_line": 115,
"start_col": 0,
"start_line": 108
} | module Hacl.Spec.Bignum.MontArithmetic
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module Euclid = FStar.Math.Euclid
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_mont_ctx_pre (#t:limb_t) (#len:BN... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Tactics.Ty... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": false,... | {
"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 |
t: Hacl.Spec.Bignum.Definitions.limb_t ->
k:
Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t
{Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx_inv k}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx",
"Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx_inv",
"Hacl.Spec.Bignum.MontArithmetic.bn_mont_nat",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.blocks0",
"Lib.IntTypes... | [] | false | false | false | false | true | let bn_field_exp_st (t: limb_t) (k: bn_mont_ctx t {bn_mont_ctx_inv k}) =
| aM: bn_mont_nat k -> bBits: size_nat -> b: lbignum t (blocks0 bBits (bits t))
-> Pure (bn_mont_nat k)
(requires bn_v b < pow2 bBits)
(ensures
fun cM ->
bn_v (bn_from_field k cM) ==
Lib.NatMod.pow_mod #(bn_v k.n) (bn_v (bn_from_field k aM)) (bn_v b)) | false | |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_load_mem_get64 | val lemma_load_mem_get64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures load_mem64 ptr (get_vale_heap h) == get_heap_val64 ptr (heap_get (coerce h)))
[SMTPat (load_mem64 ptr (get_vale_heap h))] | val lemma_load_mem_get64 (h:vale_full_heap) (ptr:int) : Lemma
(requires valid_mem64 ptr (get_vale_heap h))
(ensures load_mem64 ptr (get_vale_heap h) == get_heap_val64 ptr (heap_get (coerce h)))
[SMTPat (load_mem64 ptr (get_vale_heap h))] | let lemma_load_mem_get64 h ptr =
MS.equiv_load_mem64 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 32,
"start_col": 0,
"start_line": 29
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_full_heap -> ptr: Prims.int
-> FStar.Pervasives.Lemma
(requires Vale.X64.Memory.valid_mem64 ptr (Vale.X64.Memory.get_vale_heap h))
(ensures
Vale.X64.Memory.load_mem64 ptr (Vale.X64.Memory.get_vale_heap h) ==
Vale.Arch.MachineHeap_s.get_heap_val64 ptr
(V... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_full_heap",
"Prims.int",
"Prims.unit",
"Vale.X64.Memory_Sems.lemma_heap_get_heap",
"Vale.X64.Memory_Sems.equiv_load_mem64",
"Vale.X64.Memory.get_vale_heap"
] | [] | true | false | true | false | false | let lemma_load_mem_get64 h ptr =
| MS.equiv_load_mem64 ptr (get_vale_heap h);
MS.lemma_heap_get_heap h;
() | false |
Hacl.Spec.Bignum.MontArithmetic.fsti | Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx_inv | val bn_mont_ctx_inv : k: Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t -> Prims.logical | let bn_mont_ctx_inv (#t:limb_t) (k:bn_mont_ctx t) =
bn_v k.n < pow2 (bits t * k.len) /\
bn_mont_ctx_pre k.n /\
(1 + bn_v k.n * v k.mu) % pow2 (bits t) == 0 /\
bn_v k.r2 == pow2 (2 * bits t * k.len) % bn_v k.n | {
"file_name": "code/bignum/Hacl.Spec.Bignum.MontArithmetic.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 33,
"start_col": 0,
"start_line": 29
} | module Hacl.Spec.Bignum.MontArithmetic
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Hacl.Spec.Bignum.Definitions
module Euclid = FStar.Math.Euclid
module M = Hacl.Spec.Montgomery.Lemmas
module BN = Hacl.Spec.Bignum
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_mont_ctx_pre (#t:limb_t) (#len:BN... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Montgomery.Lemmas.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"FStar.Tactics.Ty... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Montgomery.Lemmas",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.Math.Euclid",
"short_module": "Euclid"
},
{
"abbrev": false,... | {
"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 | k: Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Hacl.Spec.Bignum.MontArithmetic.bn_mont_ctx",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__len",
"Hacl.Spec.Bignum.MontArithmetic.__proj__Mkbn_mont_ctx__item__... | [] | false | false | false | false | true | let bn_mont_ctx_inv (#t: limb_t) (k: bn_mont_ctx t) =
| bn_v k.n < pow2 (bits t * k.len) /\ bn_mont_ctx_pre k.n /\
(1 + bn_v k.n * v k.mu) % pow2 (bits t) == 0 /\ bn_v k.r2 == pow2 ((2 * bits t) * k.len) % bn_v k.n | false | |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_load_buffer_read128 | val lemma_load_buffer_read128 (h:vale_heap) (b:buffer128) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem128 (buffer_addr b h + 16 * i) h)
[SMTPat (buffer_read b i h)] | val lemma_load_buffer_read128 (h:vale_heap) (b:buffer128) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem128 (buffer_addr b h + 16 * i) h)
[SMTPat (buffer_read b i h)] | let lemma_load_buffer_read128 h b i =
lemma_load_mem128 b i h | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 49,
"start_col": 0,
"start_line": 48
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_heap -> b: Vale.X64.Memory.buffer128 -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Vale.X64.Memory.valid_buffer_read h b i)
(ensures
Vale.X64.Memory.buffer_read b i h ==
Vale.X64.Memory.load_mem128 (Vale.X64.Memory.buffer_addr b h + 16 * i) h)
[SMTPat (Vale... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_heap",
"Vale.X64.Memory.buffer128",
"Prims.int",
"Vale.X64.Memory.lemma_load_mem128",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_load_buffer_read128 h b i =
| lemma_load_mem128 b i h | false |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_to_eval_operand | val lemma_to_eval_operand (s:vale_state) (o:operand64) : Lemma
(requires valid_src_operand o s)
(ensures eval_operand o s == Ms.eval_operand o (state_to_S s))
[SMTPat (eval_operand o s)] | val lemma_to_eval_operand (s:vale_state) (o:operand64) : Lemma
(requires valid_src_operand o s)
(ensures eval_operand o s == Ms.eval_operand o (state_to_S s))
[SMTPat (eval_operand o s)] | let lemma_to_eval_operand s o =
allow_inversion tmaddr;
allow_inversion maddr | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 55,
"start_col": 0,
"start_line": 53
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Vale.X64.State.vale_state -> o: Vale.X64.Machine_s.operand64
-> FStar.Pervasives.Lemma (requires Vale.X64.State.valid_src_operand o s)
(ensures
Vale.X64.State.eval_operand o s ==
Vale.X64.Machine_Semantics_s.eval_operand o (Vale.X64.StateLemmas.state_to_S s))
[SMTPat (Vale.X64.State.eva... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.X64.State.vale_state",
"Vale.X64.Machine_s.operand64",
"FStar.Pervasives.allow_inversion",
"Vale.X64.Machine_s.maddr",
"Prims.unit",
"Vale.X64.Machine_s.tmaddr"
] | [] | true | false | true | false | false | let lemma_to_eval_operand s o =
| allow_inversion tmaddr;
allow_inversion maddr | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_siggen_256 | val test_siggen_256 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_siggen_256 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_siggen_256 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 329,
"start_col": 0,
"start_line": 267
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | vec: Hacl.Test.ECDSA.siggen_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.siggen_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FSt... | [] | false | true | false | false | false | let test_siggen_256 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB d_len d, LB qx_len qx, LB qy_len qy, LB k_len k, LB r_len r, LB s_len s =
vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then C.exit (-1l);
let bound_k = check_bound k in
let bound_d = c... | false |
Vale.X64.StateLemmas.fst | Vale.X64.StateLemmas.lemma_load_buffer_read64 | val lemma_load_buffer_read64 (h:vale_heap) (b:buffer64) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem64 (buffer_addr b h + 8 * i) h)
[SMTPat (buffer_read b i h)] | val lemma_load_buffer_read64 (h:vale_heap) (b:buffer64) (i:int) : Lemma
(requires valid_buffer_read h b i)
(ensures buffer_read b i h == load_mem64 (buffer_addr b h + 8 * i) h)
[SMTPat (buffer_read b i h)] | let lemma_load_buffer_read64 h b i =
lemma_load_mem64 b i h | {
"file_name": "vale/code/arch/x64/Vale.X64.StateLemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 46,
"start_col": 0,
"start_line": 45
} | module Vale.X64.StateLemmas
open FStar.Mul
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.State
module BS = Vale.X64.Machine_Semantics_s
module MS = Vale.X64.Memory_Sems
module ME = Vale.X64.Memory
module VST = Vale.X64.Stack_i
module VSS = Vale.X64.Stack_Sems
module F = FStar.FunctionalExtensionality
fr... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_Sems.fsti.checked",
"Vale.X64.Stack_i.fsti.checked",
"Vale.X64.Memory_Sems.fsti.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Memory.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "F"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.X64.Stack_i",
"short_module": "VST"
},
{
"abbrev": tru... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 2,
"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 | h: Vale.Arch.HeapImpl.vale_heap -> b: Vale.X64.Memory.buffer64 -> i: Prims.int
-> FStar.Pervasives.Lemma (requires Vale.X64.Memory.valid_buffer_read h b i)
(ensures
Vale.X64.Memory.buffer_read b i h ==
Vale.X64.Memory.load_mem64 (Vale.X64.Memory.buffer_addr b h + 8 * i) h)
[SMTPat (Vale.X6... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Arch.HeapImpl.vale_heap",
"Vale.X64.Memory.buffer64",
"Prims.int",
"Vale.X64.Memory.lemma_load_mem64",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_load_buffer_read64 h b i =
| lemma_load_mem64 b i h | false |
Hacl.Impl.K256.PointMul.fst | Hacl.Impl.K256.PointMul.table_inv_w5 | val table_inv_w5:BE.table_inv_t U64 15ul 32ul | val table_inv_w5:BE.table_inv_t U64 15ul 32ul | let table_inv_w5 : BE.table_inv_t U64 15ul 32ul =
[@inline_let] let len = 15ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_k256_concrete_ops in
[@inline_let] let l = 5ul in
[@inline_let] let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k ... | {
"file_name": "code/k256/Hacl.Impl.K256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 48,
"start_col": 0,
"start_line": 41
} | module Hacl.Impl.K256.PointMul
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 BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExp... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.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",
"Hacl.Spec.PrecompBaseTable256.fsti.check... | [
{
"abbrev": false,
"full_module": "Hacl.K256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": fals... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Impl.Exponentiation.table_inv_t Lib.IntTypes.U64
(15ul <: FStar.UInt32.t)
(32ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.table_inv_precomp",
"Lib.IntTypes.U64",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"FSta... | [] | false | false | false | false | false | let table_inv_w5:BE.table_inv_t U64 15ul 32ul =
| [@@ inline_let ]let len = 15ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_k256_concrete_ops in
[@@ inline_let ]let l = 5ul in
[@@ inline_let ]let table_len = 32ul in
assert_norm (pow2 (v l) == v table_len);
BE.table_inv_precomp len ctx_len k l table_len | false |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_siggen_512 | val test_siggen_512 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_siggen_512 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_siggen_512 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 459,
"start_col": 0,
"start_line": 397
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | vec: Hacl.Test.ECDSA.siggen_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.siggen_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FSt... | [] | false | true | false | false | false | let test_siggen_512 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB d_len d, LB qx_len qx, LB qy_len qy, LB k_len k, LB r_len r, LB s_len s =
vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then C.exit (-1l);
let bound_k = check_bound k in
let bound_d = c... | false |
Hacl.Impl.K256.PointMul.fst | Hacl.Impl.K256.PointMul.table_inv_w4 | val table_inv_w4:BE.table_inv_t U64 15ul 16ul | val table_inv_w4:BE.table_inv_t U64 15ul 16ul | let table_inv_w4 : BE.table_inv_t U64 15ul 16ul =
[@inline_let] let len = 15ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_k256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len | {
"file_name": "code/k256/Hacl.Impl.K256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 37,
"start_col": 0,
"start_line": 31
} | module Hacl.Impl.K256.PointMul
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 BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExp... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.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",
"Hacl.Spec.PrecompBaseTable256.fsti.check... | [
{
"abbrev": false,
"full_module": "Hacl.K256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": fals... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Impl.Exponentiation.table_inv_t Lib.IntTypes.U64
(15ul <: FStar.UInt32.t)
(16ul <: FStar.UInt32.t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.table_inv_precomp",
"Lib.IntTypes.U64",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.Exponentiation.Definitions.concrete_ops",
"FStar.UInt32.uint_to_t",
"Hacl.Impl.K256.Group.mk_k256_concrete_ops"
] | [] | false | false | false | false | false | let table_inv_w4:BE.table_inv_t U64 15ul 16ul =
| [@@ inline_let ]let len = 15ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_k256_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
BE.table_inv_precomp len ctx_len k l table_len | false |
Hacl.Impl.K256.PointMul.fst | Hacl.Impl.K256.PointMul.lemma_exp_four_fw_local | val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.q} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_k256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b))) | val lemma_exp_four_fw_local: b:BD.lbignum U64 4{BD.bn_v b < S.q} ->
Lemma (let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
LE.exp_four_fw S.mk_k256_comm_monoid g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 ==
S.to_aff_point (S.point_mul_g (BD.bn_v b))) | let lemma_exp_four_fw_local b =
let cm = S.mk_k256_comm_monoid in
let (b0, b1, b2, b3) = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.le... | {
"file_name": "code/k256/Hacl.Impl.K256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 159,
"start_col": 0,
"start_line": 150
} | module Hacl.Impl.K256.PointMul
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 BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExp... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.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",
"Hacl.Spec.PrecompBaseTable256.fsti.check... | [
{
"abbrev": false,
"full_module": "Hacl.K256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": fals... | {
"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:
Hacl.Spec.Bignum.Definitions.lbignum Lib.IntTypes.U64 4
{Hacl.Spec.Bignum.Definitions.bn_v b < Spec.K256.PointOps.q}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.PrecompBaseTable256.decompose_nat256_as_four_u64 (Hacl.Spec.Bignum.Definitions.bn_v
b)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.U64",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Spec.K256.PointOps.q",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Spec.K256.PointOps.aff_point",
"Spec.K256.PointOps.to_aff_point",
"Spec.K256.point_mul_g",
"L... | [] | false | false | true | false | false | let lemma_exp_four_fw_local b =
| let cm = S.mk_k256_comm_monoid in
let b0, b1, b2, b3 = SPT256.decompose_nat256_as_four_u64 (BD.bn_v b) in
let res = LE.exp_four_fw cm g_aff 64 b0 g_pow2_64 b1 g_pow2_128 b2 g_pow2_192 b3 4 in
assert (res == SPT256.exp_as_exp_four_nat256_precomp cm g_aff (BD.bn_v b));
SPT256.lemma_point_mul_base_precomp4 cm g_aff (BD.bn... | false |
FStar.Stubs.Tactics.V2.Builtins.fsti | FStar.Stubs.Tactics.V2.Builtins.ret_t | val ret_t : a: Type -> Type | let ret_t (a:Type) = option a & issues | {
"file_name": "ulib/FStar.Stubs.Tactics.V2.Builtins.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 479,
"start_col": 0,
"start_line": 479
} | (*
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.VConfig.fsti.checked",
"FStar.Tactics.Unseal.fsti.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Stubs.Tactics.Types.fsti.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builti... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.Unseal",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Tactics.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Effect",
"short_module": null
},
{
"abbrev": f... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Type -> Type | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Tactics.Types.issues"
] | [] | false | false | false | true | true | let ret_t (a: Type) =
| option a & issues | false | |
Hacl.Test.ECDSA.fst | Hacl.Test.ECDSA.test_siggen_384 | val test_siggen_384 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | val test_siggen_384 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) | let test_siggen_384 (vec:siggen_vector) : Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
let max_msg_len = 0 in
let LB msg_len msg,
LB d_len d,
LB qx_len qx,
LB qy_len qy,
LB k_len k,
LB r_len r,
LB s_len s = vec
in
B.recall msg;
B.recall d;
B.recall qx... | {
"file_name": "code/tests/Hacl.Test.ECDSA.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 394,
"start_col": 0,
"start_line": 332
} | module Hacl.Test.ECDSA
open FStar.HyperStack.ST
open Test.Lowstarize
open Lib.IntTypes
open Hacl.P256
open Spec.ECDSA.Test.Vectors
module L = Test.Lowstarize
module B = LowStar.Buffer
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
noextract
let sigver_vectors256_tmp = List.Tot.map
(fun x -> h x.msg, h x.qx, ... | {
"checked_file": "/",
"dependencies": [
"Test.Lowstarize.fst.checked",
"Spec.P256.fst.checked",
"Spec.ECDSA.Test.Vectors.fst.checked",
"prims.fst.checked",
"LowStar.Printf.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"... | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Test.Lowstarize",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Spec.ECDSA.Test.Vectors",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | vec: Hacl.Test.ECDSA.siggen_vector -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Test.ECDSA.siggen_vector",
"FStar.UInt32.t",
"LowStar.Buffer.buffer",
"FStar.UInt8.t",
"Prims.l_and",
"Prims.eq2",
"LowStar.Monotonic.Buffer.len",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.recallable",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"FSt... | [] | false | true | false | false | false | let test_siggen_384 (vec: siggen_vector)
: Stack unit (requires fun _ -> True) (ensures fun _ _ _ -> True) =
| let max_msg_len = 0 in
let LB msg_len msg, LB d_len d, LB qx_len qx, LB qy_len qy, LB k_len k, LB r_len r, LB s_len s =
vec
in
B.recall msg;
B.recall d;
B.recall qx;
B.recall qy;
B.recall k;
B.recall r;
B.recall s;
if not (k_len = 32ul && d_len = 32ul) then C.exit (-1l);
let bound_k = check_bound k in
let bound_d = c... | false |
Hacl.Impl.K256.PointMul.fst | Hacl.Impl.K256.PointMul.point_mul | val point_mul: out:point -> scalar:qelem -> q:point -> Stack unit
(requires fun h ->
live h out /\ live h scalar /\ live h q /\
disjoint out q /\ disjoint out scalar /\ disjoint q scalar /\
point_inv h q /\ qas_nat h scalar < S.q)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out... | val point_mul: out:point -> scalar:qelem -> q:point -> Stack unit
(requires fun h ->
live h out /\ live h scalar /\ live h q /\
disjoint out q /\ disjoint out scalar /\ disjoint q scalar /\
point_inv h q /\ qas_nat h scalar < S.q)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
point_inv h1 out... | let point_mul out scalar q =
let h0 = ST.get () in
SE.exp_fw_lemma S.mk_k256_concrete_ops (point_eval h0 q) 256 (qas_nat h0 scalar) 4;
BE.lexp_fw_consttime 15ul 0ul mk_k256_concrete_ops 4ul (null uint64) q 4ul 256ul scalar out | {
"file_name": "code/k256/Hacl.Impl.K256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 54,
"start_col": 0,
"start_line": 51
} | module Hacl.Impl.K256.PointMul
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 BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExp... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.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",
"Hacl.Spec.PrecompBaseTable256.fsti.check... | [
{
"abbrev": false,
"full_module": "Hacl.K256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": fals... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | out: Hacl.Impl.K256.Point.point -> scalar: Hacl.K256.Scalar.qelem -> q: Hacl.Impl.K256.Point.point
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Impl.K256.Point.point",
"Hacl.K256.Scalar.qelem",
"Hacl.Impl.Exponentiation.lexp_fw_consttime",
"Lib.IntTypes.U64",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.K256.Group.mk_k256_concrete_ops",
"Lib.Buffer.null",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"Prims.unit",
"Spec.Exponentiation.exp_fw... | [] | false | true | false | false | false | let point_mul out scalar q =
| let h0 = ST.get () in
SE.exp_fw_lemma S.mk_k256_concrete_ops (point_eval h0 q) 256 (qas_nat h0 scalar) 4;
BE.lexp_fw_consttime 15ul 0ul mk_k256_concrete_ops 4ul (null uint64) q 4ul 256ul scalar out | false |
Hacl.Impl.K256.PointMul.fst | Hacl.Impl.K256.PointMul.precomp_get_consttime | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 15ul 0ul mk_k256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 15ul 0ul mk_k256_concrete_ops 4ul 16ul) | val precomp_get_consttime: BE.pow_a_to_small_b_st U64 15ul 0ul mk_k256_concrete_ops 4ul 16ul
(BE.table_inv_precomp 15ul 0ul mk_k256_concrete_ops 4ul 16ul) | let precomp_get_consttime ctx a table bits_l tmp =
[@inline_let] let len = 15ul in
[@inline_let] let ctx_len = 0ul in
[@inline_let] let k = mk_k256_concrete_ops in
[@inline_let] let l = 4ul in
[@inline_let] let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | {
"file_name": "code/k256/Hacl.Impl.K256.PointMul.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 76,
"end_line": 67,
"start_col": 0,
"start_line": 60
} | module Hacl.Impl.K256.PointMul
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 BE = Hacl.Impl.Exponentiation
module ME = Hacl.Impl.MultiExp... | {
"checked_file": "/",
"dependencies": [
"Spec.K256.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",
"Hacl.Spec.PrecompBaseTable256.fsti.check... | [
{
"abbrev": false,
"full_module": "Hacl.K256.PrecompTable",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Group",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.K256.Point",
"short_module": null
},
{
"abbrev": fals... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Impl.Exponentiation.pow_a_to_small_b_st Lib.IntTypes.U64
15ul
0ul
Hacl.Impl.K256.Group.mk_k256_concrete_ops
4ul
16ul
(Hacl.Impl.Exponentiation.table_inv_precomp 15ul
0ul
Hacl.Impl.K256.Group.mk_k256_concrete_ops
4ul
16ul) | Prims.Tot | [
"total"
] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"FStar.Ghost.erased",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.clbuffer",
"Lib.IntTypes.op_Star_Bang",
"Prims.b2t",
"Prims.op_L... | [] | false | false | false | false | false | let precomp_get_consttime ctx a table bits_l tmp =
| [@@ inline_let ]let len = 15ul in
[@@ inline_let ]let ctx_len = 0ul in
[@@ inline_let ]let k = mk_k256_concrete_ops in
[@@ inline_let ]let l = 4ul in
[@@ inline_let ]let table_len = 16ul in
BE.lprecomp_get_consttime len ctx_len k l table_len ctx a table bits_l tmp | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.allP | val allP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type0)) (l: list a {l << top \/ l === top})
: Type0 | val allP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type0)) (l: list a {l << top \/ l === top})
: Type0 | let rec allP #a #b (top:b) (pred : (x:a{x << top}) -> Type0) (l : list a{l << top \/ l === top}) : Type0 =
match l with
| [] -> True
| x::xs -> pred x /\ allP top pred xs | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 28,
"start_col": 0,
"start_line": 25
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | top: b -> pred: (x: a{x << top} -> Type0) -> l: Prims.list a {l << top \/ l === top} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.precedes",
"Prims.list",
"Prims.l_or",
"Prims.op_Equals_Equals_Equals",
"Prims.l_True",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.allP"
] | [
"recursion"
] | false | false | false | false | true | let rec allP #a #b (top: b) (pred: (x: a{x << top} -> Type0)) (l: list a {l << top \/ l === top})
: Type0 =
| match l with
| [] -> True
| x :: xs -> pred x /\ allP top pred xs | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.optP0 | val optP0 (#a: _) (pred: (a -> Type0)) (o: option a) : Type0 | val optP0 (#a: _) (pred: (a -> Type0)) (o: option a) : Type0 | let optP0 #a (pred : a -> Type0) (o : option a) : Type0 =
match o with
| None -> True
| Some x -> pred x | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 33,
"start_col": 0,
"start_line": 30
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | pred: (_: a -> Type0) -> o: FStar.Pervasives.Native.option a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.option",
"Prims.l_True"
] | [] | false | false | false | true | true | let optP0 #a (pred: (a -> Type0)) (o: option a) : Type0 =
| match o with
| None -> True
| Some x -> pred x | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.opt_cmp | val opt_cmp : #a:Type -> comparator_for a -> comparator_for (option a) | val opt_cmp : #a:Type -> comparator_for a -> comparator_for (option a) | let opt_cmp cmp o1 o2 =
match o1, o2 with
| None, None -> Eq
| Some x, Some y -> cmp x y
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 129,
"start_col": 0,
"start_line": 125
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | cmp: FStar.Reflection.V2.TermEq.comparator_for a
-> FStar.Reflection.V2.TermEq.comparator_for (FStar.Pervasives.Native.option a) | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.Eq",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | true | false | let opt_cmp cmp o1 o2 =
| match o1, o2 with
| None, None -> Eq
| Some x, Some y -> cmp x y
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.namedv_cmp | val namedv_cmp : comparator_for namedv | val namedv_cmp : comparator_for namedv | let namedv_cmp x1 x2 =
let v1 = inspect_namedv x1 in
let v2 = inspect_namedv x2 in
pack_inspect_namedv x1;
pack_inspect_namedv x2;
sealed_singl v1.sort v2.sort;
if v1.uniq = v2.uniq then Eq else Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 114,
"start_col": 0,
"start_line": 108
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.namedv | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.namedv",
"Prims.op_Equality",
"Prims.nat",
"FStar.Stubs.Reflection.V2.Data.__proj__Mknamedv_view__item__uniq",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.bool",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres",
"Prims.unit",
"FStar.Sealed.sealed_sing... | [] | false | false | false | true | false | let namedv_cmp x1 x2 =
| let v1 = inspect_namedv x1 in
let v2 = inspect_namedv x2 in
pack_inspect_namedv x1;
pack_inspect_namedv x2;
sealed_singl v1.sort v2.sort;
if v1.uniq = v2.uniq then Eq else Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.valid | val valid : c: FStar.Reflection.V2.TermEq._cmpres -> x: t -> y: t -> Prims.logical | let valid #t (c:_cmpres) (x y : t) =
match c with
| Eq -> x == y
| Neq -> x =!= y
| Unknown -> True | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 19,
"end_line": 82,
"start_col": 0,
"start_line": 78
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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: FStar.Reflection.V2.TermEq._cmpres -> x: t -> y: t -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq._cmpres",
"Prims.eq2",
"Prims.l_not",
"Prims.l_True",
"Prims.logical"
] | [] | false | false | false | true | true | let valid #t (c: _cmpres) (x: t) (y: t) =
| match c with
| Eq -> x == y
| Neq -> x =!= y
| Unknown -> True | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.allP0 | val allP0 (#a: _) (pred: (a -> Type0)) (l: list a) : Type0 | val allP0 (#a: _) (pred: (a -> Type0)) (l: list a) : Type0 | let rec allP0 #a (pred : a -> Type0) (l : list a) : Type0 =
match l with
| [] -> True
| x::xs -> pred x /\ allP0 pred xs | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 23,
"start_col": 0,
"start_line": 20
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | pred: (_: a -> Type0) -> l: Prims.list a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.l_True",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.allP0"
] | [
"recursion"
] | false | false | false | true | true | let rec allP0 #a (pred: (a -> Type0)) (l: list a) : Type0 =
| match l with
| [] -> True
| x :: xs -> pred x /\ allP0 pred xs | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.optP | val optP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type0)) (o: option a {o << top}) : Type0 | val optP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type0)) (o: option a {o << top}) : Type0 | let optP #a #b (top:b) (pred : (x:a{x << top}) -> Type0) (o : option a{o << top}) : Type0 =
match o with
| None -> True
| Some x -> pred x | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 38,
"start_col": 0,
"start_line": 35
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | top: b -> pred: (x: a{x << top} -> Type0) -> o: FStar.Pervasives.Native.option a {o << top} -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.precedes",
"FStar.Pervasives.Native.option",
"Prims.l_True"
] | [] | false | false | false | false | true | let optP #a #b (top: b) (pred: (x: a{x << top} -> Type0)) (o: option a {o << top}) : Type0 =
| match o with
| None -> True
| Some x -> pred x | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.bv_cmp | val bv_cmp : comparator_for bv | val bv_cmp : comparator_for bv | let bv_cmp x1 x2 =
let v1 = inspect_bv x1 in
let v2 = inspect_bv x2 in
pack_inspect_bv x1;
pack_inspect_bv x2;
sealed_singl v1.sort v2.sort;
if v1.index = v2.index then Eq else Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 105,
"start_col": 0,
"start_line": 99
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.bv | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.bv",
"Prims.op_Equality",
"Prims.nat",
"FStar.Stubs.Reflection.V2.Data.__proj__Mkbv_view__item__index",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.bool",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres",
"Prims.unit",
"FStar.Sealed.sealed_singl",
"... | [] | false | false | false | true | false | let bv_cmp x1 x2 =
| let v1 = inspect_bv x1 in
let v2 = inspect_bv x2 in
pack_inspect_bv x1;
pack_inspect_bv x2;
sealed_singl v1.sort v2.sort;
if v1.index = v2.index then Eq else Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.either_cmp | val either_cmp : #a:Type -> #b:Type -> comparator_for a -> comparator_for b -> comparator_for (either a b) | val either_cmp : #a:Type -> #b:Type -> comparator_for a -> comparator_for b -> comparator_for (either a b) | let either_cmp cmpa cmpb e1 e2 =
match e1, e2 with
| Inl x, Inl y -> cmpa x y
| Inr x, Inr y -> cmpb x y
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 136,
"start_col": 0,
"start_line": 132
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
cmpa: FStar.Reflection.V2.TermEq.comparator_for a ->
cmpb: FStar.Reflection.V2.TermEq.comparator_for b
-> FStar.Reflection.V2.TermEq.comparator_for (FStar.Pervasives.either a b) | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"FStar.Pervasives.either",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | true | false | let either_cmp cmpa cmpb e1 e2 =
| match e1, e2 with
| Inl x, Inl y -> cmpa x y
| Inr x, Inr y -> cmpb x y
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.fv_cmp | val fv_cmp : comparator_for fv | val fv_cmp : comparator_for fv | let fv_cmp f1 f2 =
pack_inspect_fv f1;
pack_inspect_fv f2;
let n1 = inspect_fv f1 in
let n2 = inspect_fv f2 in
if n1 = n2 then Eq else Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 122,
"start_col": 0,
"start_line": 117
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.fv | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.fv",
"Prims.op_Equality",
"FStar.Stubs.Reflection.Types.name",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.bool",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres",
"FStar.Stubs.Reflection.V2.Builtins.inspect_fv",
"Prims.unit",
"FStar.Stubs.Reflection.... | [] | false | false | false | true | false | let fv_cmp f1 f2 =
| pack_inspect_fv f1;
pack_inspect_fv f2;
let n1 = inspect_fv f1 in
let n2 = inspect_fv f2 in
if n1 = n2 then Eq else Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.memP_allP0 | val memP_allP0 (#a: _) (pred: (a -> Type)) (x: a) (l: list a)
: Lemma (requires allP0 pred l /\ L.memP x l)
(ensures pred x)
[SMTPat (allP0 pred l); SMTPat (L.memP x l)] | val memP_allP0 (#a: _) (pred: (a -> Type)) (x: a) (l: list a)
: Lemma (requires allP0 pred l /\ L.memP x l)
(ensures pred x)
[SMTPat (allP0 pred l); SMTPat (L.memP x l)] | let rec memP_allP0 #a (pred : a -> Type) (x : a) (l : list a)
: Lemma (requires allP0 pred l /\ L.memP x l)
(ensures pred x)
[SMTPat (allP0 pred l); SMTPat (L.memP x l)]
= match l with
| [] -> ()
| y::ys ->
if StrongExcludedMiddle.strong_excluded_middle (x == y) then () else memP_a... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 95,
"end_line": 56,
"start_col": 0,
"start_line": 49
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | pred: (_: a -> Type0) -> x: a -> l: Prims.list a
-> FStar.Pervasives.Lemma
(requires FStar.Reflection.V2.TermEq.allP0 pred l /\ FStar.List.Tot.Base.memP x l)
(ensures pred x)
[SMTPat (FStar.Reflection.V2.TermEq.allP0 pred l); SMTPat (FStar.List.Tot.Base.memP x l)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.StrongExcludedMiddle.strong_excluded_middle",
"Prims.eq2",
"Prims.bool",
"FStar.Reflection.V2.TermEq.memP_allP0",
"Prims.unit",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.allP0",
"FStar.List.Tot.Base.memP",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar... | [
"recursion"
] | false | false | true | false | false | let rec memP_allP0 #a (pred: (a -> Type)) (x: a) (l: list a)
: Lemma (requires allP0 pred l /\ L.memP x l)
(ensures pred x)
[SMTPat (allP0 pred l); SMTPat (L.memP x l)] =
| match l with
| [] -> ()
| y :: ys ->
if StrongExcludedMiddle.strong_excluded_middle (x == y) then () else memP_allP0 pred x ys | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.ident_cmp | val ident_cmp : comparator_for ident | val ident_cmp : comparator_for ident | let ident_cmp i1 i2 =
let iv1 = inspect_ident i1 in
let iv2 = inspect_ident i2 in
pack_inspect_ident i1;
pack_inspect_ident i2;
Sealed.sealed_singl (snd iv1) (snd iv2);
eq_cmp (fst iv1) (fst iv2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 197,
"start_col": 0,
"start_line": 191
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.ident | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.ident",
"FStar.Reflection.V2.TermEq.eq_cmp",
"Prims.string",
"FStar.Pervasives.Native.fst",
"FStar.Range.range",
"Prims.unit",
"FStar.Sealed.sealed_singl",
"FStar.Range.__range",
"FStar.Pervasives.Native.snd",
"FStar.Stubs.Reflection.V2.Builtins.pack_inspect_ident",
... | [] | false | false | false | true | false | let ident_cmp i1 i2 =
| let iv1 = inspect_ident i1 in
let iv2 = inspect_ident i2 in
pack_inspect_ident i1;
pack_inspect_ident i2;
Sealed.sealed_singl (snd iv1) (snd iv2);
eq_cmp (fst iv1) (fst iv2) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.list_dec_cmp | val list_dec_cmp :
#a:Type u#aa -> #b:Type u#bb -> top1:b -> top2:b ->
f:(x:a -> y:a{x << top1 /\ y << top2} -> cmpres x y) ->
l1:(list a) -> l2:(list a){l1 << top1 /\ l2 << top2} ->
cmpres l1 l2 | val list_dec_cmp :
#a:Type u#aa -> #b:Type u#bb -> top1:b -> top2:b ->
f:(x:a -> y:a{x << top1 /\ y << top2} -> cmpres x y) ->
l1:(list a) -> l2:(list a){l1 << top1 /\ l2 << top2} ->
cmpres l1 l2 | let rec list_dec_cmp #a top1 top2 cmp l1 l2 =
match l1, l2 with
| [], [] -> Eq
| x::xs, y::ys -> cmp x y &&& list_dec_cmp top1 top2 cmp xs ys
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 158,
"start_col": 0,
"start_line": 154
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
top1: b ->
top2: b ->
f: (x: a -> y: a{x << top1 /\ y << top2} -> FStar.Reflection.V2.TermEq.cmpres x y) ->
l1: Prims.list a ->
l2: Prims.list a {l1 << top1 /\ l2 << top2}
-> FStar.Reflection.V2.TermEq.cmpres l1 l2 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_and",
"Prims.precedes",
"FStar.Reflection.V2.TermEq.cmpres",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.Eq",
"FStar.Reflection.V2.TermEq.op_Amp_Amp_Amp",
"FStar.Reflection.V2.TermEq.list_dec_cmp",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.Te... | [
"recursion"
] | false | false | false | false | false | let rec list_dec_cmp #a top1 top2 cmp l1 l2 =
| match l1, l2 with
| [], [] -> Eq
| x :: xs, y :: ys -> cmp x y &&& list_dec_cmp top1 top2 cmp xs ys
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.pair_cmp | val pair_cmp : #a:Type -> #b:Type -> comparator_for a -> comparator_for b -> comparator_for (a & b) | val pair_cmp : #a:Type -> #b:Type -> comparator_for a -> comparator_for b -> comparator_for (a & b) | let pair_cmp cmpa cmpb (a1, b1) (a2, b2) =
cmpa a1 a2 &&& cmpb b1 b2 | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 140,
"start_col": 0,
"start_line": 139
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
cmpa: FStar.Reflection.V2.TermEq.comparator_for a ->
cmpb: FStar.Reflection.V2.TermEq.comparator_for b
-> FStar.Reflection.V2.TermEq.comparator_for (a * b) | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.op_Amp_Amp_Amp",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | true | false | let pair_cmp cmpa cmpb (a1, b1) (a2, b2) =
| cmpa a1 a2 &&& cmpb b1 b2 | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.defined | val defined : r: FStar.Reflection.V2.TermEq._cmpres -> Prims.logical | let defined r = ~(Unknown? r) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 381,
"start_col": 0,
"start_line": 381
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | r: FStar.Reflection.V2.TermEq._cmpres -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq._cmpres",
"Prims.l_not",
"Prims.b2t",
"FStar.Reflection.V2.TermEq.uu___is_Unknown",
"Prims.logical"
] | [] | false | false | false | true | true | let defined r =
| ~(Unknown? r) | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.memP_dec | val memP_dec (#a: _) (x: a) (l: list a)
: Lemma (requires L.memP x l) (ensures x << l) [SMTPat (L.memP x l)] | val memP_dec (#a: _) (x: a) (l: list a)
: Lemma (requires L.memP x l) (ensures x << l) [SMTPat (L.memP x l)] | let rec memP_dec #a (x : a) (l : list a)
: Lemma (requires L.memP x l)
(ensures x << l)
[SMTPat (L.memP x l)]
= match l with
| [] -> ()
| y::ys ->
if StrongExcludedMiddle.strong_excluded_middle (x == y) then () else memP_dec x ys | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 88,
"end_line": 65,
"start_col": 0,
"start_line": 58
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | x: a -> l: Prims.list a
-> FStar.Pervasives.Lemma (requires FStar.List.Tot.Base.memP x l)
(ensures x << l)
[SMTPat (FStar.List.Tot.Base.memP x l)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"FStar.StrongExcludedMiddle.strong_excluded_middle",
"Prims.eq2",
"Prims.bool",
"FStar.Reflection.V2.TermEq.memP_dec",
"Prims.unit",
"FStar.List.Tot.Base.memP",
"Prims.squash",
"Prims.precedes",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec memP_dec #a (x: a) (l: list a)
: Lemma (requires L.memP x l) (ensures x << l) [SMTPat (L.memP x l)] =
| match l with
| [] -> ()
| y :: ys -> if StrongExcludedMiddle.strong_excluded_middle (x == y) then () else memP_dec x ys | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.memP_allP | val memP_allP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type)) (x: a) (l: list a {l << top})
: Lemma (requires allP top pred l /\ L.memP x l)
(ensures x << top /\ pred x)
[SMTPat (allP top pred l); SMTPat (L.memP x l)] | val memP_allP (#a #b: _) (top: b) (pred: (x: a{x << top} -> Type)) (x: a) (l: list a {l << top})
: Lemma (requires allP top pred l /\ L.memP x l)
(ensures x << top /\ pred x)
[SMTPat (allP top pred l); SMTPat (L.memP x l)] | let rec memP_allP #a #b (top:b) (pred : (x:a{x << top}) -> Type) (x : a) (l : list a{l << top})
: Lemma (requires allP top pred l /\ L.memP x l)
(ensures x << top /\ pred x)
[SMTPat (allP top pred l); SMTPat (L.memP x l)]
= match l with
| [] -> ()
| y::ys ->
if StrongExcludedMiddle... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 98,
"end_line": 47,
"start_col": 0,
"start_line": 40
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | top: b -> pred: (x: a{x << top} -> Type0) -> x: a -> l: Prims.list a {l << top}
-> FStar.Pervasives.Lemma
(requires FStar.Reflection.V2.TermEq.allP top pred l /\ FStar.List.Tot.Base.memP x l)
(ensures x << top /\ pred x)
[SMTPat (FStar.Reflection.V2.TermEq.allP top pred l); SMTPat (FStar.List.Tot.Ba... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"Prims.list",
"FStar.StrongExcludedMiddle.strong_excluded_middle",
"Prims.eq2",
"Prims.bool",
"FStar.Reflection.V2.TermEq.memP_allP",
"Prims.unit",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.allP",
"FStar.List.Tot.Base.memP",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.... | [
"recursion"
] | false | false | true | false | false | let rec memP_allP #a #b (top: b) (pred: (x: a{x << top} -> Type)) (x: a) (l: list a {l << top})
: Lemma (requires allP top pred l /\ L.memP x l)
(ensures x << top /\ pred x)
[SMTPat (allP top pred l); SMTPat (L.memP x l)] =
| match l with
| [] -> ()
| y :: ys ->
if StrongExcludedMiddle.strong_excluded_middle (x == y) then () else memP_allP top pred x ys | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.def2 | val def2 : f: (_: _ -> _: _ -> FStar.Reflection.V2.TermEq._cmpres) -> l1: Prims.list _ -> l2: Prims.list _
-> Prims.logical | let def2 f l1 l2 =(forall x y. L.memP x l1 /\ L.memP y l2 ==> defined (f x y)) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 78,
"end_line": 383,
"start_col": 0,
"start_line": 383
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | f: (_: _ -> _: _ -> FStar.Reflection.V2.TermEq._cmpres) -> l1: Prims.list _ -> l2: Prims.list _
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq._cmpres",
"Prims.list",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"FStar.List.Tot.Base.memP",
"FStar.Reflection.V2.TermEq.defined",
"Prims.logical"
] | [] | false | false | false | true | true | let def2 f l1 l2 =
| (forall x y. L.memP x l1 /\ L.memP y l2 ==> defined (f x y)) | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.list_cmp | val list_cmp : #a:Type u#aa -> comparator_for a -> comparator_for (list a) | val list_cmp : #a:Type u#aa -> comparator_for a -> comparator_for (list a) | let rec list_cmp #a cmp l1 l2 =
match l1, l2 with
| [], [] -> Eq
| x::xs, y::ys -> cmp x y &&& list_cmp cmp xs ys
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 147,
"start_col": 0,
"start_line": 143
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | cmp: FStar.Reflection.V2.TermEq.comparator_for a
-> FStar.Reflection.V2.TermEq.comparator_for (Prims.list a) | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.Eq",
"FStar.Reflection.V2.TermEq.op_Amp_Amp_Amp",
"FStar.Reflection.V2.TermEq.list_cmp",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2... | [
"recursion"
] | false | false | false | true | false | let rec list_cmp #a cmp l1 l2 =
| match l1, l2 with
| [], [] -> Eq
| x :: xs, y :: ys -> cmp x y &&& list_cmp cmp xs ys
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.eq_cmp | val eq_cmp : #a:eqtype -> comparator_for a | val eq_cmp : #a:eqtype -> comparator_for a | let eq_cmp x y = if x = y then Eq else Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 183,
"start_col": 0,
"start_line": 183
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for a | Prims.Tot | [
"total"
] | [] | [
"Prims.eqtype",
"Prims.op_Equality",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.bool",
"FStar.Reflection.V2.TermEq.Neq",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | false | false | let eq_cmp x y =
| if x = y then Eq else Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.opt_dec_cmp | val opt_dec_cmp : #a:Type -> #b:Type -> top1:b -> top2:b ->
(f : (x:a -> y:a{x << top1 /\ y << top2} -> cmpres x y)) ->
o1:(option a){o1 << top1} -> o2:(option a){o2 << top2} ->
cmpres o1 o2 | val opt_dec_cmp : #a:Type -> #b:Type -> top1:b -> top2:b ->
(f : (x:a -> y:a{x << top1 /\ y << top2} -> cmpres x y)) ->
o1:(option a){o1 << top1} -> o2:(option a){o2 << top2} ->
cmpres o1 o2 | let opt_dec_cmp top1 top2 cmp o1 o2 =
match o1, o2 with
| None, None -> Eq
| Some x, Some y -> cmp x y
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 168,
"start_col": 0,
"start_line": 164
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
top1: b ->
top2: b ->
f: (x: a -> y: a{x << top1 /\ y << top2} -> FStar.Reflection.V2.TermEq.cmpres x y) ->
o1: FStar.Pervasives.Native.option a {o1 << top1} ->
o2: FStar.Pervasives.Native.option a {o2 << top2}
-> FStar.Reflection.V2.TermEq.cmpres o1 o2 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_and",
"Prims.precedes",
"FStar.Reflection.V2.TermEq.cmpres",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.Eq",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.TermEq.Neq",
"Prims.l_or"
] | [] | false | false | false | false | false | let opt_dec_cmp top1 top2 cmp o1 o2 =
| match o1, o2 with
| None, None -> Eq
| Some x, Some y -> cmp x y
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.range_cmp | val range_cmp : comparator_for range | val range_cmp : comparator_for range | let range_cmp r1 r2 =
Sealed.sealed_singl r1 r2;
Eq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 4,
"end_line": 188,
"start_col": 0,
"start_line": 186
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Range.range | Prims.Tot | [
"total"
] | [] | [
"FStar.Range.range",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.unit",
"FStar.Sealed.sealed_singl",
"FStar.Range.__range",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | true | false | let range_cmp r1 r2 =
| Sealed.sealed_singl r1 r2;
Eq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.either_dec_cmp | val either_dec_cmp : #a:Type -> #b:Type -> #c:Type -> top1:c -> top2:c ->
(x:a -> y:a{x<<top1 /\ y<<top2} -> cmpres x y) ->
(x:b -> y:b{x<<top1 /\ y<<top2} -> cmpres x y) ->
e1 :(either a b){e1 << top1} ->
e2 :(either a b){e2 << top2} ->
cmpres e1 e2 | val either_dec_cmp : #a:Type -> #b:Type -> #c:Type -> top1:c -> top2:c ->
(x:a -> y:a{x<<top1 /\ y<<top2} -> cmpres x y) ->
(x:b -> y:b{x<<top1 /\ y<<top2} -> cmpres x y) ->
e1 :(either a b){e1 << top1} ->
e2 :(either a b){e2 << top2} ->
cmpres e1 e2 | let either_dec_cmp top1 top2 cmpa cmpb e1 e2 =
match e1, e2 with
| Inl x, Inl y -> cmpa x y
| Inr x, Inr y -> cmpb x y
| _ -> Neq | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 180,
"start_col": 0,
"start_line": 176
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
top1: c ->
top2: c ->
cmpa: (x: a -> y: a{x << top1 /\ y << top2} -> FStar.Reflection.V2.TermEq.cmpres x y) ->
cmpb: (x: b -> y: b{x << top1 /\ y << top2} -> FStar.Reflection.V2.TermEq.cmpres x y) ->
e1: FStar.Pervasives.either a b {e1 << top1} ->
e2: FStar.Pervasives.either a b {e2 << top2}
... | Prims.Tot | [
"total"
] | [] | [
"Prims.l_and",
"Prims.precedes",
"FStar.Reflection.V2.TermEq.cmpres",
"FStar.Pervasives.either",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.Reflection.V2.TermEq.Neq",
"Prims.l_or"
] | [] | false | false | false | false | false | let either_dec_cmp top1 top2 cmpa cmpb e1 e2 =
| match e1, e2 with
| Inl x, Inl y -> cmpa x y
| Inr x, Inr y -> cmpb x y
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_cmp | val univ_cmp : comparator_for universe | val univ_cmp : comparator_for universe | let rec univ_cmp (u1 u2 : universe) =
pack_inspect_universe u1;
pack_inspect_universe u2;
let uv1 = inspect_universe u1 in
let uv2 = inspect_universe u2 in
match uv1, uv2 with
| Uv_Zero, Uv_Zero -> Eq
| Uv_Succ u1, Uv_Succ u2 -> univ_cmp u1 u2
| Uv_Max us1, Uv_Max us2 -> list_dec_cmp u1 u2 univ_cmp us1 ... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 213,
"start_col": 0,
"start_line": 200
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.universe | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.universe_view",
"FStar.Reflection.V2.TermEq.Eq",
"FStar.Reflection.V2.TermEq.univ_cmp",
"FStar.Stubs.Reflection.V2.Data.universes",
"FStar.Reflection.V2.TermEq.list_dec_cmp",
"Prims.nat",
"FS... | [
"recursion"
] | false | false | false | true | false | let rec univ_cmp (u1 u2: universe) =
| pack_inspect_universe u1;
pack_inspect_universe u2;
let uv1 = inspect_universe u1 in
let uv2 = inspect_universe u2 in
match uv1, uv2 with
| Uv_Zero, Uv_Zero -> Eq
| Uv_Succ u1, Uv_Succ u2 -> univ_cmp u1 u2
| Uv_Max us1, Uv_Max us2 -> list_dec_cmp u1 u2 univ_cmp us1 us2
| Uv_BVar v1, Uv_BVar v2 -> eq_cmp v1 v2
| Uv_Name... | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.ctxu_cmp | val ctxu_cmp : comparator_for ctx_uvar_and_subst | val ctxu_cmp : comparator_for ctx_uvar_and_subst | let ctxu_cmp _ _ = Unknown | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 230,
"start_col": 0,
"start_line": 230
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.Types.ctx_uvar_and_subst | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.ctx_uvar_and_subst",
"FStar.Reflection.V2.TermEq.Unknown",
"FStar.Reflection.V2.TermEq.cmpres"
] | [] | false | false | false | true | false | let ctxu_cmp _ _ =
| Unknown | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.const_cmp | val const_cmp : comparator_for vconst | val const_cmp : comparator_for vconst | let const_cmp c1 c2 =
match c1, c2 with
| C_Unit, C_Unit -> Eq
| C_Int i1, C_Int i2 -> eq_cmp i1 i2
| C_True, C_True -> Eq
| C_False, C_False -> Eq
| C_String s1, C_String s2 -> eq_cmp s1 s2
| C_Range r1, C_Range r2 -> range_cmp r1 r2
| C_Reify, C_Reify -> Eq
| C_Reflect n1, C_Reflect n2 -> eq_cmp n1 ... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 12,
"end_line": 226,
"start_col": 0,
"start_line": 216
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | FStar.Reflection.V2.TermEq.comparator_for FStar.Stubs.Reflection.V2.Data.vconst | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.V2.Data.vconst",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.Eq",
"Prims.int",
"FStar.Reflection.V2.TermEq.eq_cmp",
"Prims.string",
"FStar.Range.range",
"FStar.Reflection.V2.TermEq.range_cmp",
"FStar.Stubs.Reflection.Types.name",
"FStar.Pervasives.Native... | [] | false | false | false | true | false | let const_cmp c1 c2 =
| match c1, c2 with
| C_Unit, C_Unit -> Eq
| C_Int i1, C_Int i2 -> eq_cmp i1 i2
| C_True, C_True -> Eq
| C_False, C_False -> Eq
| C_String s1, C_String s2 -> eq_cmp s1 s2
| C_Range r1, C_Range r2 -> range_cmp r1 r2
| C_Reify, C_Reify -> Eq
| C_Reflect n1, C_Reflect n2 -> eq_cmp n1 n2
| _ -> Neq | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_univ_UvMax | val faithful_univ_UvMax (u: universe) (us: list universe)
: Lemma (requires inspect_universe u == Uv_Max us /\ faithful_univ u)
(ensures allP u faithful_univ us) | val faithful_univ_UvMax (u: universe) (us: list universe)
: Lemma (requires inspect_universe u == Uv_Max us /\ faithful_univ u)
(ensures allP u faithful_univ us) | let faithful_univ_UvMax (u : universe) (us : list universe)
: Lemma (requires inspect_universe u == Uv_Max us /\ faithful_univ u)
(ensures allP u faithful_univ us)
= assert_norm (faithful_univ u <==> allP u faithful_univ us) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 62,
"end_line": 417,
"start_col": 0,
"start_line": 414
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | u268: FStar.Stubs.Reflection.Types.universe -> us: Prims.list FStar.Stubs.Reflection.Types.universe
-> FStar.Pervasives.Lemma
(requires
FStar.Stubs.Reflection.V2.Builtins.inspect_universe u268 ==
FStar.Stubs.Reflection.V2.Data.Uv_Max us /\ FStar.Reflection.V2.TermEq.faithful_univ u268)
(en... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"Prims.list",
"FStar.Pervasives.assert_norm",
"Prims.l_iff",
"FStar.Reflection.V2.TermEq.faithful_univ",
"FStar.Reflection.V2.TermEq.allP",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"FStar.Stubs.Reflection.V2.Data.universe_view",
"FStar.Stubs.Reflection.V... | [] | true | false | true | false | false | let faithful_univ_UvMax (u: universe) (us: list universe)
: Lemma (requires inspect_universe u == Uv_Max us /\ faithful_univ u)
(ensures allP u faithful_univ us) =
| assert_norm (faithful_univ u <==> allP u faithful_univ us) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_term | val faithful_term : Type0 | let faithful_term = t:term{faithful t} | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 815,
"start_col": 0,
"start_line": 815
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.TermEq.faithful"
] | [] | false | false | false | true | true | let faithful_term =
| t: term{faithful t} | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_universe | val faithful_universe : Type0 | let faithful_universe = t:universe{faithful_univ t} | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 51,
"end_line": 828,
"start_col": 0,
"start_line": 828
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Reflection.V2.TermEq.faithful_univ"
] | [] | false | false | false | true | true | let faithful_universe =
| t: universe{faithful_univ t} | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.defined_list | val defined_list (#a: _) (f: comparator_for a) (l1 l2: list a)
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_cmp f l1 l2)) | val defined_list (#a: _) (f: comparator_for a) (l1 l2: list a)
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_cmp f l1 l2)) | let rec defined_list #a (f : comparator_for a) (l1 l2 : list a)
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_cmp f l1 l2))
= match l1, l2 with
| [], [] -> ()
| x::xs, y::ys -> defined_list f xs ys
| _ -> () | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 390,
"start_col": 0,
"start_line": 385
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | f: FStar.Reflection.V2.TermEq.comparator_for a -> l1: Prims.list a -> l2: Prims.list a
-> FStar.Pervasives.Lemma (requires FStar.Reflection.V2.TermEq.def2 f l1 l2)
(ensures FStar.Reflection.V2.TermEq.defined (FStar.Reflection.V2.TermEq.list_cmp f l1 l2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.defined_list",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"FStar.Reflection.V2.TermEq.def2",
"Prims.squash",
"FStar.Reflection.V2.TermEq.defined",
"FStar.Reflection.V2.Te... | [
"recursion"
] | false | false | true | false | false | let rec defined_list #a (f: comparator_for a) (l1: list a) (l2: list a)
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_cmp f l1 l2)) =
| match l1, l2 with
| [], [] -> ()
| x :: xs, y :: ys -> defined_list f xs ys
| _ -> () | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_univ | val faithful_univ : universe -> Type0 | val faithful_univ : universe -> Type0 | let rec faithful_univ (u : universe) =
match inspect_universe u with
| Uv_Unif _ -> False (* We just forbid this *)
| Uv_Unk
| Uv_Zero
| Uv_BVar _
| Uv_Name _ -> True
| Uv_Succ u -> faithful_univ u
| Uv_Max us -> allP u faithful_univ us | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 40,
"end_line": 412,
"start_col": 0,
"start_line": 402
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | u262: FStar.Stubs.Reflection.Types.universe -> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Stubs.Reflection.V2.Builtins.inspect_universe",
"FStar.Stubs.Reflection.Types.universe_uvar",
"Prims.l_False",
"Prims.l_True",
"Prims.nat",
"FStar.Stubs.Reflection.Types.univ_name",
"FStar.Reflection.V2.TermEq.faithful_univ",
"FStar.Stubs.Reflection.V2... | [
"recursion"
] | false | false | false | true | true | let rec faithful_univ (u: universe) =
| match inspect_universe u with
| Uv_Unif _ -> False
| Uv_Unk | Uv_Zero | Uv_BVar _ | Uv_Name _ -> True
| Uv_Succ u -> faithful_univ u
| Uv_Max us -> allP u faithful_univ us | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_eq_UvMax | val univ_eq_UvMax (u1 u2: universe) (us1 us2: list universe)
: Lemma (requires inspect_universe u1 == Uv_Max us1 /\ inspect_universe u2 == Uv_Max us2)
(ensures univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2) | val univ_eq_UvMax (u1 u2: universe) (us1 us2: list universe)
: Lemma (requires inspect_universe u1 == Uv_Max us1 /\ inspect_universe u2 == Uv_Max us2)
(ensures univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2) | let univ_eq_UvMax (u1 u2 : universe) (us1 us2 : list universe)
: Lemma (requires inspect_universe u1 == Uv_Max us1 /\
inspect_universe u2 == Uv_Max us2)
(ensures univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2)
= assert_norm (univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 71,
"end_line": 423,
"start_col": 0,
"start_line": 419
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
u1: FStar.Stubs.Reflection.Types.universe ->
u2: FStar.Stubs.Reflection.Types.universe ->
us1: Prims.list FStar.Stubs.Reflection.Types.universe ->
us2: Prims.list FStar.Stubs.Reflection.Types.universe
-> FStar.Pervasives.Lemma
(requires
FStar.Stubs.Reflection.V2.Builtins.inspect_univers... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"Prims.list",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.Reflection.V2.TermEq._cmpres",
"Prims.l_or",
"FStar.Reflection.V2.TermEq.valid",
"FStar.Reflection.V2.TermEq.univ_cmp",
"FStar.Reflection.V2.TermEq.list_dec_cmp",
"Prims.unit",
"Prims.l_and... | [] | true | false | true | false | false | let univ_eq_UvMax (u1 u2: universe) (us1 us2: list universe)
: Lemma (requires inspect_universe u1 == Uv_Max us1 /\ inspect_universe u2 == Uv_Max us2)
(ensures univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2) =
| assert_norm (univ_cmp u1 u2 == list_dec_cmp u1 u2 univ_cmp us1 us2) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_Pat_Cons | val faithful_Pat_Cons (p: pattern) (f: fv) (ous: option universes) (subpats: list (pattern & bool))
: Lemma (requires p == Pat_Cons f ous subpats /\ faithful_pattern p)
(ensures allP p faithful_pattern_arg subpats) | val faithful_Pat_Cons (p: pattern) (f: fv) (ous: option universes) (subpats: list (pattern & bool))
: Lemma (requires p == Pat_Cons f ous subpats /\ faithful_pattern p)
(ensures allP p faithful_pattern_arg subpats) | let faithful_Pat_Cons (p : pattern) (f:fv) (ous : option universes) (subpats : list (pattern & bool))
: Lemma (requires p == Pat_Cons f ous subpats /\ faithful_pattern p)
(ensures allP p faithful_pattern_arg subpats)
= assert_norm (faithful_pattern p ==> allP p faithful_pattern_arg subpats) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 76,
"end_line": 589,
"start_col": 0,
"start_line": 586
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
p: FStar.Stubs.Reflection.V2.Data.pattern ->
f: FStar.Stubs.Reflection.Types.fv ->
ous: FStar.Pervasives.Native.option FStar.Stubs.Reflection.V2.Data.universes ->
subpats: Prims.list (FStar.Stubs.Reflection.V2.Data.pattern * Prims.bool)
-> FStar.Pervasives.Lemma
(requires
p == FStar.Stu... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.V2.Data.pattern",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.V2.Data.universes",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"FStar.Pervasives.assert_norm",
"Prims.l_imp",
"FStar.Reflection.V2.TermEq.faithf... | [] | true | false | true | false | false | let faithful_Pat_Cons (p: pattern) (f: fv) (ous: option universes) (subpats: list (pattern & bool))
: Lemma (requires p == Pat_Cons f ous subpats /\ faithful_pattern p)
(ensures allP p faithful_pattern_arg subpats) =
| assert_norm (faithful_pattern p ==> allP p faithful_pattern_arg subpats) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_Tv_Match | val faithful_Tv_Match (t sc: term) (o: option match_returns_ascription) (brs: list branch)
: Lemma (requires inspect_ln t == Tv_Match sc o brs /\ faithful t)
(ensures allP t faithful_branch brs) | val faithful_Tv_Match (t sc: term) (o: option match_returns_ascription) (brs: list branch)
: Lemma (requires inspect_ln t == Tv_Match sc o brs /\ faithful t)
(ensures allP t faithful_branch brs) | let faithful_Tv_Match (t : term) (sc : term) (o : option match_returns_ascription) (brs : list branch)
: Lemma (requires inspect_ln t == Tv_Match sc o brs /\ faithful t)
(ensures allP t faithful_branch brs)
= assert_norm (faithful t ==> allP t faithful_branch brs) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 59,
"end_line": 574,
"start_col": 0,
"start_line": 571
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
t: FStar.Stubs.Reflection.Types.term ->
sc: FStar.Stubs.Reflection.Types.term ->
o: FStar.Pervasives.Native.option FStar.Stubs.Reflection.Types.match_returns_ascription ->
brs: Prims.list FStar.Stubs.Reflection.V2.Data.branch
-> FStar.Pervasives.Lemma
(requires
FStar.Stubs.Reflection.V2... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.Types.match_returns_ascription",
"Prims.list",
"FStar.Stubs.Reflection.V2.Data.branch",
"FStar.Pervasives.assert_norm",
"Prims.l_imp",
"FStar.Reflection.V2.TermEq.faithful",
"FStar.Reflection.V2.TermEq.all... | [] | true | false | true | false | false | let faithful_Tv_Match (t sc: term) (o: option match_returns_ascription) (brs: list branch)
: Lemma (requires inspect_ln t == Tv_Match sc o brs /\ faithful t)
(ensures allP t faithful_branch brs) =
| assert_norm (faithful t ==> allP t faithful_branch brs) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.defined_list_dec | val defined_list_dec
(#a #b: _)
(t1 t2: b)
(f: comparator_for a)
(l1: list a {l1 << t1})
(l2: list a {l2 << t2})
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_dec_cmp t1 t2 f l1 l2)) | val defined_list_dec
(#a #b: _)
(t1 t2: b)
(f: comparator_for a)
(l1: list a {l1 << t1})
(l2: list a {l2 << t2})
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_dec_cmp t1 t2 f l1 l2)) | let rec defined_list_dec #a #b (t1 t2 : b) (f : comparator_for a)
(l1 : list a{l1 << t1})
(l2 : list a{l2 << t2})
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_dec_cmp t1 t2 f l1 l2))
= match l1, l2 with
| [], [] -> ()
| x::xs, y::ys -> defined_list_dec t1 t2 f xs ys
| _ -> () | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 13,
"end_line": 399,
"start_col": 0,
"start_line": 392
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
t1: b ->
t2: b ->
f: FStar.Reflection.V2.TermEq.comparator_for a ->
l1: Prims.list a {l1 << t1} ->
l2: Prims.list a {l2 << t2}
-> FStar.Pervasives.Lemma (requires FStar.Reflection.V2.TermEq.def2 f l1 l2)
(ensures
FStar.Reflection.V2.TermEq.defined (FStar.Reflection.V2.TermEq.list_de... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Reflection.V2.TermEq.comparator_for",
"Prims.list",
"Prims.precedes",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.TermEq.defined_list_dec",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"FStar.Reflection.V2.TermEq.def2",
"Prims.squash",
"FStar.Reflection.V2.TermEq.defined",
... | [
"recursion"
] | false | false | true | false | false | let rec defined_list_dec
#a
#b
(t1: b)
(t2: b)
(f: comparator_for a)
(l1: list a {l1 << t1})
(l2: list a {l2 << t2})
: Lemma (requires (def2 f l1 l2)) (ensures defined (list_dec_cmp t1 t2 f l1 l2)) =
| match l1, l2 with
| [], [] -> ()
| x :: xs, y :: ys -> defined_list_dec t1 t2 f xs ys
| _ -> () | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_faithful_lemma | val univ_faithful_lemma (u1 u2 : universe) : Lemma (requires faithful_univ u1 /\ faithful_univ u2) (ensures defined (univ_cmp u1 u2)) | val univ_faithful_lemma (u1 u2 : universe) : Lemma (requires faithful_univ u1 /\ faithful_univ u2) (ensures defined (univ_cmp u1 u2)) | let rec univ_faithful_lemma (u1 u2 : universe) =
match inspect_universe u1, inspect_universe u2 with
| Uv_Zero, Uv_Zero -> ()
| Uv_Succ u1, Uv_Succ u2 -> univ_faithful_lemma u1 u2
| Uv_Max us1, Uv_Max us2 ->
(****)faithful_univ_UvMax u1 us1;
(***)faithful_univ_UvMax u2 us2;
univ_faithful_lemma_list ... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 453,
"start_col": 0,
"start_line": 426
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | u1: FStar.Stubs.Reflection.Types.universe -> u2: FStar.Stubs.Reflection.Types.universe
-> FStar.Pervasives.Lemma
(requires
FStar.Reflection.V2.TermEq.faithful_univ u1 /\ FStar.Reflection.V2.TermEq.faithful_univ u2)
(ensures FStar.Reflection.V2.TermEq.defined (FStar.Reflection.V2.TermEq.univ_cmp u1... | FStar.Pervasives.Lemma | [
"lemma"
] | [
"univ_faithful_lemma",
"univ_faithful_lemma_list"
] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.V2.Data.universe_view",
"FStar.Stubs.Reflection.V2.Builtins.inspect_universe",
"FStar.Reflection.V2.TermEq.univ_faithful_lemma",
"FStar.Stubs.Reflection.V2.Data.universes",
"Prims.unit",
"FStar.Reflect... | [
"mutual recursion"
] | false | false | true | false | false | let rec univ_faithful_lemma (u1 u2: universe) =
| match inspect_universe u1, inspect_universe u2 with
| Uv_Zero, Uv_Zero -> ()
| Uv_Succ u1, Uv_Succ u2 -> univ_faithful_lemma u1 u2
| Uv_Max us1, Uv_Max us2 ->
faithful_univ_UvMax u1 us1;
faithful_univ_UvMax u2 us2;
univ_faithful_lemma_list u1 u2 us1 us2;
univ_eq_UvMax u1 u2 us1 us2;
()
| Uv_BVar _, Uv_BVar _ ... | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_binder | val faithful_binder (b: binder) : Type0 | val faithful_binder (b: binder) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | b: FStar.Stubs.Reflection.Types.binder -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.Types.binder",
"FStar.Stubs.Reflection.V2.Builtins.inspect_binder",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"Prims.list",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.ppname_t",
"Prims.l_and",
"FStar.Reflection.V2.T... | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_binder (b: binder) : Type0 =
| match inspect_binder b with
| { sort = sort ; qual = q ; attrs = attrs } ->
faithful sort /\ faithful_qual q /\ faithful_attrs attrs | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_eq | val univ_eq (u1 u2: universe) : (b: bool{b ==> u1 == u2}) | val univ_eq (u1 u2: universe) : (b: bool{b ==> u1 == u2}) | let univ_eq (u1 u2 : universe) : (b:bool{b ==> u1 == u2}) =
Eq? (univ_cmp u1 u2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 830,
"start_col": 0,
"start_line": 829
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | u1: FStar.Stubs.Reflection.Types.universe -> u2: FStar.Stubs.Reflection.Types.universe
-> b: Prims.bool{b ==> u1 == u2} | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.universe",
"FStar.Reflection.V2.TermEq.uu___is_Eq",
"FStar.Reflection.V2.TermEq.univ_cmp",
"Prims.bool",
"Prims.l_imp",
"Prims.b2t",
"Prims.eq2"
] | [] | false | false | false | false | false | let univ_eq (u1 u2: universe) : (b: bool{b ==> u1 == u2}) =
| Eq? (univ_cmp u1 u2) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_faithful_lemma_list | val univ_faithful_lemma_list
(#b: _)
(u1 u2: b)
(us1: list universe {us1 << u1})
(us2: list universe {us2 << u2})
: Lemma (requires allP u1 faithful_univ us1 /\ allP u2 faithful_univ us2)
(ensures defined (list_dec_cmp u1 u2 univ_cmp us1 us2))
(decreases us1) | val univ_faithful_lemma_list
(#b: _)
(u1 u2: b)
(us1: list universe {us1 << u1})
(us2: list universe {us2 << u2})
: Lemma (requires allP u1 faithful_univ us1 /\ allP u2 faithful_univ us2)
(ensures defined (list_dec_cmp u1 u2 univ_cmp us1 us2))
(decreases us1) | let rec univ_faithful_lemma (u1 u2 : universe) =
match inspect_universe u1, inspect_universe u2 with
| Uv_Zero, Uv_Zero -> ()
| Uv_Succ u1, Uv_Succ u2 -> univ_faithful_lemma u1 u2
| Uv_Max us1, Uv_Max us2 ->
(****)faithful_univ_UvMax u1 us1;
(***)faithful_univ_UvMax u2 us2;
univ_faithful_lemma_list ... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 453,
"start_col": 0,
"start_line": 426
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
u1: b ->
u2: b ->
us1: Prims.list FStar.Stubs.Reflection.Types.universe {us1 << u1} ->
us2: Prims.list FStar.Stubs.Reflection.Types.universe {us2 << u2}
-> FStar.Pervasives.Lemma
(requires
FStar.Reflection.V2.TermEq.allP u1 FStar.Reflection.V2.TermEq.faithful_univ us1 /\
FStar.R... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [
"univ_faithful_lemma",
"univ_faithful_lemma_list"
] | [
"Prims.list",
"FStar.Stubs.Reflection.Types.universe",
"Prims.precedes",
"FStar.Reflection.V2.TermEq.defined_list_dec",
"FStar.Reflection.V2.TermEq.univ_cmp",
"Prims.unit",
"FStar.Classical.Sugar.forall_intro",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"FStar.List.Tot.Base.memP",
"FStar.... | [
"mutual recursion"
] | false | false | true | false | false | let rec univ_faithful_lemma_list
#b
(u1: b)
(u2: b)
(us1: list universe {us1 << u1})
(us2: list universe {us2 << u2})
: Lemma (requires allP u1 faithful_univ us1 /\ allP u2 faithful_univ us2)
(ensures defined (list_dec_cmp u1 u2 univ_cmp us1 us2))
(decreases us1) =
| introduce forall x y . L.memP x us1 /\ L.memP y us2 ==> defined (univ_cmp x y)
with (introduce forall y . L.memP x us1 /\ L.memP y us2 ==> defined (univ_cmp x y)
with (introduce (L.memP x us1 /\ L.memP y us2) ==> (defined (univ_cmp x y))
with h. (univ_faithful_lemma x y)));
defined_list_dec u1 u2 univ_cmp us1 us2 | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.term_eq_dec | val term_eq_dec (t1 t2: faithful_term) : (b: bool{b <==> t1 == t2}) | val term_eq_dec (t1 t2: faithful_term) : (b: bool{b <==> t1 == t2}) | let term_eq_dec (t1 t2 : faithful_term) : (b:bool{b <==> t1 == t2}) =
faithful_lemma t1 t2;
Eq? (term_cmp t1 t2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 825,
"start_col": 0,
"start_line": 823
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | t1: FStar.Reflection.V2.TermEq.faithful_term -> t2: FStar.Reflection.V2.TermEq.faithful_term
-> b: Prims.bool{b <==> t1 == t2} | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.faithful_term",
"FStar.Reflection.V2.TermEq.uu___is_Eq",
"FStar.Reflection.V2.TermEq.term_cmp",
"Prims.unit",
"FStar.Reflection.V2.TermEq.faithful_lemma",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2"
] | [] | false | false | false | false | false | let term_eq_dec (t1 t2: faithful_term) : (b: bool{b <==> t1 == t2}) =
| faithful_lemma t1 t2;
Eq? (term_cmp t1 t2) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful | val faithful : term -> Type0 | val faithful : term -> Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | t: FStar.Stubs.Reflection.Types.term -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Builtins.inspect_ln",
"FStar.Stubs.Reflection.Types.namedv",
"Prims.l_True",
"FStar.Stubs.Reflection.Types.bv",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Stubs.Reflection.V2.Data.vconst",
"FStar.Stubs.Reflection.V2.Data.universes",
"FSt... | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful t =
| match inspect_ln t with
| Tv_Var _ | Tv_BVar _ | Tv_FVar _ | Tv_Unknown | Tv_Const _ -> True
| Tv_UInst f us -> allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a -> faithful h /\ faithful_arg a
| Tv_Abs b t -> faithful_binder b /\ faithful t
| Tv_Arrow b c -> faithful_binder b /\ faithful_comp c
| Tv_Type u -> ... | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_comp | val faithful_comp : c: FStar.Stubs.Reflection.Types.comp -> Prims.logical | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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: FStar.Stubs.Reflection.Types.comp -> Prims.logical | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.Types.comp",
"FStar.Stubs.Reflection.V2.Builtins.inspect_comp",
"FStar.Stubs.Reflection.Types.typ",
"FStar.Reflection.V2.TermEq.faithful",
"FStar.Stubs.Reflection.Types.term",
"Prims.l_and",
"FStar.Stubs.Reflection.V2.Data.universes",
"FStar.Stubs.Reflection.Types.name",
"Pri... | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_comp c =
| match inspect_comp c with
| C_Total t -> faithful t
| C_GTotal t -> faithful t
| C_Lemma pre post pats -> faithful pre /\ faithful post /\ faithful pats
| C_Eff us ef r args decs ->
allP c faithful_univ us /\ faithful r /\ allP c faithful_arg args /\ allP c faithful decs | false | |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_pattern_arg | val faithful_pattern_arg (pb: (pattern * bool)) : Type0 | val faithful_pattern_arg (pb: (pattern * bool)) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | pb: (FStar.Stubs.Reflection.V2.Data.pattern * Prims.bool) -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Pervasives.Native.tuple2",
"FStar.Stubs.Reflection.V2.Data.pattern",
"Prims.bool",
"FStar.Reflection.V2.TermEq.faithful_pattern",
"FStar.Pervasives.Native.fst"
] | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_pattern_arg (pb: pattern * bool) : Type0 =
| faithful_pattern (fst pb) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_arg | val faithful_arg (a: argv) : Type0 | val faithful_arg (a: argv) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | a: FStar.Stubs.Reflection.V2.Data.argv -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.V2.Data.argv",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.faithful",
"FStar.Pervasives.Native.fst",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Reflection.V2.TermEq.faithful_qual",
"FStar.Pervasives.Native.snd"
] | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_arg (a: argv) : Type0 =
| faithful (fst a) /\ faithful_qual (snd a) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.univ_eq_dec | val univ_eq_dec (u1 u2: faithful_universe) : (b: bool{b <==> u1 == u2}) | val univ_eq_dec (u1 u2: faithful_universe) : (b: bool{b <==> u1 == u2}) | let univ_eq_dec (u1 u2 : faithful_universe) : (b:bool{b <==> u1 == u2}) =
univ_faithful_lemma u1 u2;
Eq? (univ_cmp u1 u2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 833,
"start_col": 0,
"start_line": 831
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | u1: FStar.Reflection.V2.TermEq.faithful_universe -> u2: FStar.Reflection.V2.TermEq.faithful_universe
-> b: Prims.bool{b <==> u1 == u2} | Prims.Tot | [
"total"
] | [] | [
"FStar.Reflection.V2.TermEq.faithful_universe",
"FStar.Reflection.V2.TermEq.uu___is_Eq",
"FStar.Reflection.V2.TermEq.univ_cmp",
"Prims.unit",
"FStar.Reflection.V2.TermEq.univ_faithful_lemma",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2"
] | [] | false | false | false | false | false | let univ_eq_dec (u1 u2: faithful_universe) : (b: bool{b <==> u1 == u2}) =
| univ_faithful_lemma u1 u2;
Eq? (univ_cmp u1 u2) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.pat_eq_Pat_Cons | val pat_eq_Pat_Cons
(p1 p2: pattern)
(f1 f2: fv)
(ous1 ous2: option universes)
(args1 args2: list (pattern & bool))
: Lemma (requires p1 == Pat_Cons f1 ous1 args1 /\ p2 == Pat_Cons f2 ous2 args2)
(ensures
pat_cmp p1 p2 ==
(fv_cmp f1 f2 &&& opt_dec_cmp p1 p2 (list_dec_cm... | val pat_eq_Pat_Cons
(p1 p2: pattern)
(f1 f2: fv)
(ous1 ous2: option universes)
(args1 args2: list (pattern & bool))
: Lemma (requires p1 == Pat_Cons f1 ous1 args1 /\ p2 == Pat_Cons f2 ous2 args2)
(ensures
pat_cmp p1 p2 ==
(fv_cmp f1 f2 &&& opt_dec_cmp p1 p2 (list_dec_cm... | let pat_eq_Pat_Cons (p1 p2 : pattern) (f1 f2 : fv) (ous1 ous2 : option universes) (args1 args2 : list (pattern & bool))
: Lemma (requires p1 == Pat_Cons f1 ous1 args1 /\ p2 == Pat_Cons f2 ous2 args2)
(ensures pat_cmp p1 p2 == (fv_cmp f1 f2
&&& opt_dec_cmp p1 p2 (list_dec_... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 84,
"end_line": 598,
"start_col": 0,
"start_line": 591
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 |
p1: FStar.Stubs.Reflection.V2.Data.pattern ->
p2: FStar.Stubs.Reflection.V2.Data.pattern ->
f1: FStar.Stubs.Reflection.Types.fv ->
f2: FStar.Stubs.Reflection.Types.fv ->
ous1: FStar.Pervasives.Native.option FStar.Stubs.Reflection.V2.Data.universes ->
ous2: FStar.Pervasives.Native.option FStar.S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Stubs.Reflection.V2.Data.pattern",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.V2.Data.universes",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.Reflection.V2.TermEq._cmpres"... | [] | true | false | true | false | false | let pat_eq_Pat_Cons
(p1 p2: pattern)
(f1 f2: fv)
(ous1 ous2: option universes)
(args1 args2: list (pattern & bool))
: Lemma (requires p1 == Pat_Cons f1 ous1 args1 /\ p2 == Pat_Cons f2 ous2 args2)
(ensures
pat_cmp p1 p2 ==
(fv_cmp f1 f2 &&& opt_dec_cmp p1 p2 (list_dec_cm... | assert_norm (pat_cmp p1 p2 ==
(fv_cmp f1 f2 &&& opt_dec_cmp p1 p2 (list_dec_cmp p1 p2 univ_cmp) ous1 ous2 &&&
list_dec_cmp p1 p2 pat_arg_cmp args1 args2)) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_branch | val faithful_branch (b: branch) : Type0 | val faithful_branch (b: branch) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | b: FStar.Stubs.Reflection.V2.Data.branch -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.V2.Data.branch",
"FStar.Stubs.Reflection.V2.Data.pattern",
"FStar.Stubs.Reflection.Types.term",
"Prims.l_and",
"FStar.Reflection.V2.TermEq.faithful_pattern",
"FStar.Reflection.V2.TermEq.faithful"
] | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_branch (b: branch) : Type0 =
| let p, t = b in
faithful_pattern p /\ faithful t | false |
FStar.LexicographicOrdering.fst | FStar.LexicographicOrdering.closure_transitive | val closure_transitive (#a: Type u#a) (#r_a: binrel u#a u#ra a) (x y z: a)
: Lemma (requires closure r_a x y /\ squash (r_a y z))
(ensures closure r_a x z)
[SMTPat (closure r_a x y); SMTPat (r_a y z)] | val closure_transitive (#a: Type u#a) (#r_a: binrel u#a u#ra a) (x y z: a)
: Lemma (requires closure r_a x y /\ squash (r_a y z))
(ensures closure r_a x z)
[SMTPat (closure r_a x y); SMTPat (r_a y z)] | let closure_transitive (#a:Type u#a) (#r_a:binrel u#a u#ra a) (x y z:a)
: Lemma
(requires closure r_a x y /\
squash (r_a y z))
(ensures closure r_a x z)
[SMTPat (closure r_a x y);
SMTPat (r_a y z)]
= assert (closure r_a y z) | {
"file_name": "ulib/FStar.LexicographicOrdering.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 33,
"start_col": 0,
"start_line": 26
} | (*
Copyright 2021 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.ReflexiveTransitiveClosure.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.LexicographicOrdering.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ReflexiveTransitiveClosure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: a -> y: a -> z: a
-> FStar.Pervasives.Lemma
(requires FStar.ReflexiveTransitiveClosure.closure r_a x y /\ Prims.squash (r_a y z))
(ensures FStar.ReflexiveTransitiveClosure.closure r_a x z)
[SMTPat (FStar.ReflexiveTransitiveClosure.closure r_a x y); SMTPat (r_a y z)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.WellFounded.binrel",
"Prims._assert",
"FStar.ReflexiveTransitiveClosure.closure",
"Prims.unit",
"Prims.l_and",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | true | false | true | false | false | let closure_transitive (#a: Type u#a) (#r_a: binrel u#a u#ra a) (x y z: a)
: Lemma (requires closure r_a x y /\ squash (r_a y z))
(ensures closure r_a x z)
[SMTPat (closure r_a x y); SMTPat (r_a y z)] =
| assert (closure r_a y z) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_pattern | val faithful_pattern (p: pattern) : Type0 | val faithful_pattern (p: pattern) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | p: FStar.Stubs.Reflection.V2.Data.pattern -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.V2.Data.pattern",
"FStar.Stubs.Reflection.V2.Data.vconst",
"Prims.l_True",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Pervasives.Native.option",
"FStar.Stubs.Reflection.V2.Data.universes",
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.bool",
"Prims.l_and",
"FStar.... | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_pattern (p: pattern) : Type0 =
| match p with
| Pat_Constant _ -> True
| Pat_Cons head univs subpats ->
optP p (allP p faithful_univ) univs /\ allP p faithful_pattern_arg subpats
| Pat_Var _ _ -> True
| Pat_Dot_Term None -> True
| Pat_Dot_Term (Some t) -> faithful t | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.term_eq | val term_eq (t1 t2: term) : (b: bool{b ==> t1 == t2}) | val term_eq (t1 t2: term) : (b: bool{b ==> t1 == t2}) | let term_eq (t1 t2 : term) : (b:bool{b ==> t1 == t2}) =
Eq? (term_cmp t1 t2) | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 820,
"start_col": 0,
"start_line": 819
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | t1: FStar.Stubs.Reflection.Types.term -> t2: FStar.Stubs.Reflection.Types.term
-> b: Prims.bool{b ==> t1 == t2} | Prims.Tot | [
"total"
] | [] | [
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.TermEq.uu___is_Eq",
"FStar.Reflection.V2.TermEq.term_cmp",
"Prims.bool",
"Prims.l_imp",
"Prims.b2t",
"Prims.eq2"
] | [] | false | false | false | false | false | let term_eq (t1 t2: term) : (b: bool{b ==> t1 == t2}) =
| Eq? (term_cmp t1 t2) | false |
FStar.LexicographicOrdering.fst | FStar.LexicographicOrdering.lex_t_wf | val lex_t_wf (#a:Type u#a) (#b:a -> Type u#b)
(#r_a:binrel u#a u#ra a)
(#r_b:(x:a -> binrel u#b u#rb (b x)))
(wf_a:well_founded r_a)
(wf_b:(x:a -> well_founded (r_b x)))
: well_founded (lex_t r_a r_b) | val lex_t_wf (#a:Type u#a) (#b:a -> Type u#b)
(#r_a:binrel u#a u#ra a)
(#r_b:(x:a -> binrel u#b u#rb (b x)))
(wf_a:well_founded r_a)
(wf_b:(x:a -> well_founded (r_b x)))
: well_founded (lex_t r_a r_b) | let lex_t_wf #_ #_ #_ #_ wf_a wf_b =
fun (| x, y |) -> AccIntro (lex_t_wf_aux x (wf_a x) wf_b y (wf_b x y)) | {
"file_name": "ulib/FStar.LexicographicOrdering.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 72,
"end_line": 96,
"start_col": 0,
"start_line": 95
} | (*
Copyright 2021 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Squash.fsti.checked",
"FStar.ReflexiveTransitiveClosure.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.LexicographicOrdering.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.ReflexiveTransitiveClosure",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"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 | wf_a: FStar.WellFounded.well_founded r_a -> wf_b: (x: a -> FStar.WellFounded.well_founded (r_b x))
-> FStar.WellFounded.well_founded (FStar.LexicographicOrdering.lex_t r_a r_b) | Prims.Tot | [
"total"
] | [] | [
"FStar.WellFounded.binrel",
"FStar.WellFounded.well_founded",
"Prims.dtuple2",
"FStar.WellFounded.AccIntro",
"FStar.LexicographicOrdering.lex_t",
"Prims.Mkdtuple2",
"FStar.LexicographicOrdering.lex_t_wf_aux",
"FStar.WellFounded.acc"
] | [] | false | false | false | false | false | let lex_t_wf #_ #_ #_ #_ wf_a wf_b =
| fun (| x , y |) -> AccIntro (lex_t_wf_aux x (wf_a x) wf_b y (wf_b x y)) | false |
FStar.Reflection.V2.TermEq.fst | FStar.Reflection.V2.TermEq.faithful_qual | val faithful_qual (q: aqualv) : Type0 | val faithful_qual (q: aqualv) : Type0 | let rec faithful t =
match inspect_ln t with
| Tv_Var _
| Tv_BVar _
| Tv_FVar _
| Tv_Unknown
| Tv_Const _ -> True
| Tv_UInst f us ->
allP t faithful_univ us
| Tv_Unsupp -> False
| Tv_App h a ->
faithful h /\ faithful_arg a
| Tv_Abs b t ->
faithful_binder b /\ faithful t
| Tv_Arrow b... | {
"file_name": "ulib/FStar.Reflection.V2.TermEq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 28,
"end_line": 547,
"start_col": 0,
"start_line": 456
} | module FStar.Reflection.V2.TermEq
open FStar.Stubs.Reflection.Types
open FStar.Stubs.Reflection.V2.Data
open FStar.Stubs.Reflection.V2.Builtins
module L = FStar.List.Tot
(* "SMT may not be able to prove the types of ... and ... to be equal,
if the proof fails, try annotating these with the same type" *)
#set-options... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Stubs.Reflection.V2.Data.fsti.checked",
"FStar.Stubs.Reflection.V2.Builtins.fsti.checked",
"FStar.Stubs.Reflection.Types.fsti.checked",
"FStar.StrongExcludedMiddle.fst.checked",
"FStar.Sealed.fsti.checked",
"FStar.Perva... | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Builtins",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Stubs.Reflection.V2.Data",
"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 | q: FStar.Stubs.Reflection.V2.Data.aqualv -> Type0 | Prims.Tot | [
"total"
] | [
"faithful",
"faithful_arg",
"faithful_qual",
"faithful_binder",
"faithful_branch",
"faithful_pattern",
"faithful_pattern_arg",
"faithful_attrs",
"faithful_comp"
] | [
"FStar.Stubs.Reflection.V2.Data.aqualv",
"Prims.l_True",
"FStar.Stubs.Reflection.Types.term",
"FStar.Reflection.V2.TermEq.faithful"
] | [
"mutual recursion"
] | false | false | false | true | true | let rec faithful_qual (q: aqualv) : Type0 =
| match q with
| Q_Implicit -> True
| Q_Explicit -> True
| Q_Meta m -> faithful m | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.