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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
LowStar.Printf.fst | LowStar.Printf.intro_normal_f | val intro_normal_f (#a: Type) (b: (a -> Type)) (f: (x: a -> b x)) : (x: (normal a) -> normal (b x)) | val intro_normal_f (#a: Type) (b: (a -> Type)) (f: (x: a -> b x)) : (x: (normal a) -> normal (b x)) | let intro_normal_f (#a:Type) (b: (a -> Type)) (f:(x:a -> b x))
: (x:(normal a) -> normal (b x))
= f | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 470,
"start_col": 0,
"start_line": 468
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"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 | b: (_: a -> Type) -> f: (x: a -> b x) -> x: LowStar.Printf.normal a -> LowStar.Printf.normal (b x) | Prims.Tot | [
"total"
] | [] | [
"LowStar.Printf.normal"
] | [] | false | false | false | false | false | let intro_normal_f (#a: Type) (b: (a -> Type)) (f: (x: a -> b x)) : (x: (normal a) -> normal (b x)) =
| f | false |
AllocSTwHeaps.fst | AllocSTwHeaps.ist_witnessed | val ist_witnessed : p:
FStar.Preorder.predicate FStar.Monotonic.Heap.heap
{FStar.Preorder.stable p AllocSTwHeaps.heap_rel}
-> Type0 | let ist_witnessed (p:predicate FStar.Heap.heap{stable p heap_rel}) = witnessed heap_rel p | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 89,
"end_line": 80,
"start_col": 0,
"start_line": 80
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 |
p:
FStar.Preorder.predicate FStar.Monotonic.Heap.heap
{FStar.Preorder.stable p AllocSTwHeaps.heap_rel}
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Preorder.predicate",
"FStar.Monotonic.Heap.heap",
"FStar.Preorder.stable",
"AllocSTwHeaps.heap_rel",
"FStar.Monotonic.Witnessed.witnessed"
] | [] | false | false | false | false | true | let ist_witnessed (p: predicate FStar.Heap.heap {stable p heap_rel}) =
| witnessed heap_rel p | false | |
AllocSTwHeaps.fst | AllocSTwHeaps.alloc | val alloc : #a:Type ->
x:a ->
AllocST (ref a) (fun _ -> True)
(fun h0 r h1 -> r `Heap.unused_in` h0 /\
FStar.Heap.contains h1 r /\
h1 == FStar.Heap.upd h0 r x) | val alloc : #a:Type ->
x:a ->
AllocST (ref a) (fun _ -> True)
(fun h0 r h1 -> r `Heap.unused_in` h0 /\
FStar.Heap.contains h1 r /\
h1 == FStar.Heap.upd h0 r x) | let alloc #a x =
let h = ist_get () in
let r = gen_ref h in
ist_put (upd h r x);
ist_witness (contains r);
r | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 3,
"end_line": 157,
"start_col": 0,
"start_line": 152
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 -> AllocSTwHeaps.AllocST (AllocSTwHeaps.ref a) | AllocSTwHeaps.AllocST | [] | [] | [
"AllocSTwHeaps.ref",
"Prims.unit",
"AllocSTwHeaps.ist_witness",
"AllocSTwHeaps.contains",
"AllocSTwHeaps.ist_put",
"AllocSTwHeaps.upd",
"FStar.Monotonic.Heap.unused_in",
"FStar.Heap.trivial_preorder",
"AllocSTwHeaps.gen_ref",
"FStar.Monotonic.Heap.heap",
"AllocSTwHeaps.ist_get"
] | [] | false | true | false | false | false | let alloc #a x =
| let h = ist_get () in
let r = gen_ref h in
ist_put (upd h r x);
ist_witness (contains r);
r | false |
AllocSTwHeaps.fst | AllocSTwHeaps.precise_write | val precise_write : #a:Type ->
r:ref a ->
x:a ->
AllocST unit (fun h0 -> FStar.Heap.contains h0 r)
(fun h0 _ h1 -> h1 == FStar.Heap.upd h0 r x) | val precise_write : #a:Type ->
r:ref a ->
x:a ->
AllocST unit (fun h0 -> FStar.Heap.contains h0 r)
(fun h0 _ h1 -> h1 == FStar.Heap.upd h0 r x) | let precise_write #a r x =
let h = ist_get () in
ist_put (upd h r x) | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 189,
"start_col": 0,
"start_line": 187
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 | r: AllocSTwHeaps.ref a -> x: a -> AllocSTwHeaps.AllocST Prims.unit | AllocSTwHeaps.AllocST | [] | [] | [
"AllocSTwHeaps.ref",
"AllocSTwHeaps.ist_put",
"AllocSTwHeaps.upd",
"Prims.unit",
"FStar.Monotonic.Heap.heap",
"AllocSTwHeaps.ist_get"
] | [] | false | true | false | false | false | let precise_write #a r x =
| let h = ist_get () in
ist_put (upd h r x) | false |
AllocSTwHeaps.fst | AllocSTwHeaps.recall | val recall : #a:Type ->
r:ref a ->
AllocST unit (fun h0 -> True)
(fun h0 _ h1 -> h0 == h1 /\
FStar.Heap.contains h1 r) | val recall : #a:Type ->
r:ref a ->
AllocST unit (fun h0 -> True)
(fun h0 _ h1 -> h0 == h1 /\
FStar.Heap.contains h1 r) | let recall #a r =
ist_recall (contains r) | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 200,
"start_col": 0,
"start_line": 199
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 | r: AllocSTwHeaps.ref a -> AllocSTwHeaps.AllocST Prims.unit | AllocSTwHeaps.AllocST | [] | [] | [
"AllocSTwHeaps.ref",
"AllocSTwHeaps.ist_recall",
"AllocSTwHeaps.contains",
"Prims.unit"
] | [] | false | true | false | false | false | let recall #a r =
| ist_recall (contains r) | false |
AllocSTwHeaps.fst | AllocSTwHeaps.read | val read : #a:Type ->
r:ref a ->
AllocST a (fun _ -> True)
(fun h0 x h1 -> h0 == h1 /\
x == FStar.Heap.sel h1 r) | val read : #a:Type ->
r:ref a ->
AllocST a (fun _ -> True)
(fun h0 x h1 -> h0 == h1 /\
x == FStar.Heap.sel h1 r) | let read #a r =
let h = ist_get () in
sel h r | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 9,
"end_line": 167,
"start_col": 0,
"start_line": 165
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 | r: AllocSTwHeaps.ref a -> AllocSTwHeaps.AllocST a | AllocSTwHeaps.AllocST | [] | [] | [
"AllocSTwHeaps.ref",
"AllocSTwHeaps.sel",
"FStar.Monotonic.Heap.heap",
"AllocSTwHeaps.ist_get"
] | [] | false | true | false | false | false | let read #a r =
| let h = ist_get () in
sel h r | false |
AllocSTwHeaps.fst | AllocSTwHeaps.write | val write : #a:Type ->
r:ref a ->
x:a ->
AllocST unit (fun h0 -> FStar.Heap.contains h0 r)
(fun h0 _ h1 -> h1 == FStar.Heap.upd h0 r x) | val write : #a:Type ->
r:ref a ->
x:a ->
AllocST unit (fun h0 -> FStar.Heap.contains h0 r)
(fun h0 _ h1 -> h1 == FStar.Heap.upd h0 r x) | let write #a r x =
let h = ist_get () in
ist_put (upd h r x) | {
"file_name": "examples/preorders/AllocSTwHeaps.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 177,
"start_col": 0,
"start_line": 175
} | (*
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.StrongExcludedMiddle.fst.checked",
"FStar.ST.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Witnessed.fsti.checked",
"FStar.Heap.fst.checked"
],
"interface_file": false... | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Witnessed",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Preorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.ST",
"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 | r: AllocSTwHeaps.ref a -> x: a -> AllocSTwHeaps.AllocST Prims.unit | AllocSTwHeaps.AllocST | [] | [] | [
"AllocSTwHeaps.ref",
"AllocSTwHeaps.ist_put",
"AllocSTwHeaps.upd",
"Prims.unit",
"FStar.Monotonic.Heap.heap",
"AllocSTwHeaps.ist_get"
] | [] | false | true | false | false | false | let write #a r x =
| let h = ist_get () in
ist_put (upd h r x) | false |
LowStar.Printf.fst | LowStar.Printf.skip' | val skip' (s: format_string) : interpret_format_string s | val skip' (s: format_string) : interpret_format_string s | let skip' (s:format_string) : interpret_format_string s =
normalize_term
(match parse_format_string s with
| Some frags -> aux frags [] (fun _ -> ())) | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 47,
"end_line": 492,
"start_col": 0,
"start_line": 489
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: LowStar.Printf.format_string -> LowStar.Printf.interpret_format_string s | Prims.Tot | [
"total"
] | [] | [
"LowStar.Printf.format_string",
"FStar.Pervasives.normalize_term",
"LowStar.Printf.interpret_format_string",
"LowStar.Printf.parse_format_string",
"LowStar.Printf.fragments",
"LowStar.Printf.aux",
"Prims.Nil",
"LowStar.Printf.frag_t",
"Prims.list",
"Prims.unit"
] | [] | false | false | false | false | false | let skip' (s: format_string) : interpret_format_string s =
| normalize_term (match parse_format_string s with | Some frags -> aux frags [] (fun _ -> ())) | false |
LowStar.Printf.fst | LowStar.Printf.test2 | val test2 (x: (int * int)) (print_pair: ((int * int) -> StTrivial unit))
: Stack unit (requires (fun h0 -> True)) (ensures (fun h0 _ h1 -> h0 == h1)) | val test2 (x: (int * int)) (print_pair: ((int * int) -> StTrivial unit))
: Stack unit (requires (fun h0 -> True)) (ensures (fun h0 _ h1 -> h0 == h1)) | let test2 (x:(int * int)) (print_pair:(int * int) -> StTrivial unit)
: Stack unit
(requires (fun h0 -> True))
(ensures (fun h0 _ h1 -> h0 == h1))
= printf "Hello pair %a" print_pair x done | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 527,
"start_col": 0,
"start_line": 523
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"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 |
x: (Prims.int * Prims.int) ->
print_pair: (_: (Prims.int * Prims.int) -> LowStar.Printf.StTrivial Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.Pervasives.Native.tuple2",
"Prims.int",
"Prims.unit",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.eq2"
] | [] | false | true | false | false | false | let test2 (x: (int * int)) (print_pair: ((int * int) -> StTrivial unit))
: Stack unit (requires (fun h0 -> True)) (ensures (fun h0 _ h1 -> h0 == h1)) =
| printf "Hello pair %a" print_pair x done | false |
LowStar.Printf.fst | LowStar.Printf.printf' | val printf' (s: format_string) : interpret_format_string s | val printf' (s: format_string) : interpret_format_string s | let printf' (s:format_string) : interpret_format_string s =
normalize_term
(match parse_format_string s with
| Some frags -> aux frags [] print_frags) | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 463,
"start_col": 0,
"start_line": 460
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: LowStar.Printf.format_string -> LowStar.Printf.interpret_format_string s | Prims.Tot | [
"total"
] | [] | [
"LowStar.Printf.format_string",
"FStar.Pervasives.normalize_term",
"LowStar.Printf.interpret_format_string",
"LowStar.Printf.parse_format_string",
"LowStar.Printf.fragments",
"LowStar.Printf.aux",
"Prims.Nil",
"LowStar.Printf.frag_t",
"LowStar.Printf.print_frags"
] | [] | false | false | false | false | false | let printf' (s: format_string) : interpret_format_string s =
| normalize_term (match parse_format_string s with | Some frags -> aux frags [] print_frags) | false |
LowStar.Printf.fst | LowStar.Printf.test3 | val test3 (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) | val test3 (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) | let test3 (m:UInt64.t) (l:UInt32.t) (#r:_) (#s:_) (x:LB.mbuffer bool r s{LB.len x = l})
: Stack unit
(requires (fun h0 -> LB.live h0 x))
(ensures (fun h0 _ h1 -> h0 == h1))
= skip "Hello %b Low* %uL Printf %xb %s"
true //%b boolean
m //%uL u64
l x //%xb (buff... | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 538,
"start_col": 0,
"start_line": 529
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: FStar.UInt64.t ->
l: FStar.UInt32.t ->
x: LowStar.Monotonic.Buffer.mbuffer Prims.bool r s {LowStar.Monotonic.Buffer.len x = l}
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.UInt64.t",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.srel",
"Prims.bool",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.b2t",
"Prims.op_Equality",
"LowStar.Monotonic.Buffer.len",
"LowStar.Printf.skip",
"LowStar.Printf.done",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Mono... | [] | false | true | false | false | false | let test3 (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) =
| skip "Hello %b Low* %uL Printf %xb %s" true m l x "bye" done | false |
LowStar.Printf.fst | LowStar.Printf.aux | val aux (frags: fragments) (acc: list frag_t) (fp: fragment_printer) : interpret_frags frags acc | val aux (frags: fragments) (acc: list frag_t) (fp: fragment_printer) : interpret_frags frags acc | let rec aux (frags:fragments) (acc:list frag_t) (fp: fragment_printer) : interpret_frags frags acc =
match frags with
| [] ->
let f (l:lift u#0 u#1 unit)
: Stack unit
(requires fun h0 -> live_frags h0 acc)
(ensures fun h0 _ h1 -> h0 == h1)
= fp acc
in
(f <: interpret_frags []... | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 95,
"end_line": 440,
"start_col": 0,
"start_line": 399
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"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 |
frags: LowStar.Printf.fragments ->
acc: Prims.list LowStar.Printf.frag_t ->
fp: LowStar.Printf.fragment_printer
-> LowStar.Printf.interpret_frags frags acc | Prims.Tot | [
"total"
] | [] | [
"LowStar.Printf.fragments",
"Prims.list",
"LowStar.Printf.frag_t",
"LowStar.Printf.fragment_printer",
"LowStar.Printf.interpret_frags",
"Prims.Nil",
"LowStar.Printf.fragment",
"LowStar.Printf.lift",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Printf.live_frags",
"Prims.eq2",
"Pr... | [
"recursion"
] | false | false | false | false | false | let rec aux (frags: fragments) (acc: list frag_t) (fp: fragment_printer) : interpret_frags frags acc =
| match frags with
| [] ->
let f (l: lift u#0 u#1 unit)
: Stack unit (requires fun h0 -> live_frags h0 acc) (ensures fun h0 _ h1 -> h0 == h1) =
fp acc
in
(f <: interpret_frags [] acc)
| Frag s :: rest -> coerce (aux rest (Inl s :: acc) fp)
| Interpolate (Base t) :: args ->
let f (x: base_typ_as_type t) ... | false |
LowStar.Printf.fst | LowStar.Printf.test | val test (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) | val test (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) | let test (m:UInt64.t) (l:UInt32.t) (#r:_) (#s:_) (x:LB.mbuffer bool r s{LB.len x = l})
: Stack unit
(requires (fun h0 -> LB.live h0 x))
(ensures (fun h0 _ h1 -> h0 == h1))
= printf "Hello %b Low* %uL Printf %xb %s"
true //%b boolean
m //%uL u64
l x //%xb (buf... | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 18,
"end_line": 521,
"start_col": 0,
"start_line": 512
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
m: FStar.UInt64.t ->
l: FStar.UInt32.t ->
x: LowStar.Monotonic.Buffer.mbuffer Prims.bool r s {LowStar.Monotonic.Buffer.len x = l}
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"FStar.UInt64.t",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.srel",
"Prims.bool",
"LowStar.Monotonic.Buffer.mbuffer",
"Prims.b2t",
"Prims.op_Equality",
"LowStar.Monotonic.Buffer.len",
"LowStar.Printf.printf",
"LowStar.Printf.done",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Mo... | [] | false | true | false | false | false | let test (m: UInt64.t) (l: UInt32.t) (#r #s: _) (x: LB.mbuffer bool r s {LB.len x = l})
: Stack unit (requires (fun h0 -> LB.live h0 x)) (ensures (fun h0 _ h1 -> h0 == h1)) =
| printf "Hello %b Low* %uL Printf %xb %s" true m l x "bye" done | false |
LowStar.Printf.fst | LowStar.Printf.print_frags | val print_frags (acc: list frag_t)
: Stack unit (requires fun h0 -> live_frags h0 acc) (ensures fun h0 _ h1 -> h0 == h1) | val print_frags (acc: list frag_t)
: Stack unit (requires fun h0 -> live_frags h0 acc) (ensures fun h0 _ h1 -> h0 == h1) | let rec print_frags (acc:list frag_t)
: Stack unit
(requires fun h0 -> live_frags h0 acc)
(ensures fun h0 _ h1 -> h0 == h1)
= match acc with
| [] -> ()
| hd::tl ->
print_frags tl;
(match hd with
| Inl s -> print_string s
| Inr (| Base t, Lift value |) ->
(match t w... | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 386,
"start_col": 0,
"start_line": 349
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"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 | acc: Prims.list LowStar.Printf.frag_t -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Prims.list",
"LowStar.Printf.frag_t",
"Prims.unit",
"Prims.string",
"LowStar.Printf.print_string",
"LowStar.Printf.base_typ",
"LowStar.Printf.base_typ_as_type",
"LowStar.Printf.print_bool",
"LowStar.Printf.print_char",
"LowStar.Printf.print_u8",
"LowStar.Printf.print_u16",
"LowStar.Printf.pri... | [
"recursion"
] | false | true | false | false | false | let rec print_frags (acc: list frag_t)
: Stack unit (requires fun h0 -> live_frags h0 acc) (ensures fun h0 _ h1 -> h0 == h1) =
| match acc with
| [] -> ()
| hd :: tl ->
print_frags tl;
(match hd with
| Inl s -> print_string s
| Inr (| Base t , Lift value |) ->
(match t with
| Bool -> print_bool value
| Char -> print_char value
| String -> print_string value
| U8 -> print_u8 value
| U16 ->... | false |
LowStar.Printf.fst | LowStar.Printf.parse_format | val parse_format (s: list char) : Tot (option fragments) (decreases (L.length s)) | val parse_format (s: list char) : Tot (option fragments) (decreases (L.length s)) | let rec parse_format
(s:list char)
: Tot (option fragments)
(decreases (L.length s))
= let add_dir (d:arg) (ods : option fragments)
= match ods with
| None -> None
| Some ds -> Some (Interpolate d::ds)
in
let head_buffer (ods:option fragments)
= match ods with
| Some ... | {
"file_name": "ulib/LowStar.Printf.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 225,
"start_col": 0,
"start_line": 169
} | (*
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",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Pervasives.fsti.checked",
... | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "LB"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: Prims.list FStar.String.char
-> Prims.Tot (FStar.Pervasives.Native.option LowStar.Printf.fragments) | Prims.Tot | [
"total",
""
] | [] | [
"Prims.list",
"FStar.String.char",
"FStar.Pervasives.Native.Some",
"LowStar.Printf.fragments",
"Prims.Nil",
"LowStar.Printf.fragment",
"FStar.Pervasives.Native.None",
"LowStar.Printf.Any",
"LowStar.Printf.parse_format",
"Prims.Cons",
"LowStar.Printf.Base",
"LowStar.Printf.U8",
"LowStar.Print... | [
"recursion"
] | false | false | false | true | false | let rec parse_format (s: list char) : Tot (option fragments) (decreases (L.length s)) =
| let add_dir (d: arg) (ods: option fragments) =
match ods with
| None -> None
| Some ds -> Some (Interpolate d :: ds)
in
let head_buffer (ods: option fragments) =
match ods with
| Some (Interpolate (Base t) :: rest) -> Some (Interpolate (Array t) :: rest)
| _ -> None
in
let cons_frag (c: char) (ods: option f... | false |
FStar.Pure.BreakVC.fst | FStar.Pure.BreakVC.mono_lem | val mono_lem () : Lemma (pure_wp_monotonic unit break_wp') | val mono_lem () : Lemma (pure_wp_monotonic unit break_wp') | let mono_lem () : Lemma (pure_wp_monotonic unit break_wp') =
assert (pure_wp_monotonic unit break_wp') by begin
norm [delta];
l_to_r [`spinoff_eq]
end | {
"file_name": "ulib/FStar.Pure.BreakVC.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 5,
"end_line": 9,
"start_col": 0,
"start_line": 5
} | module FStar.Pure.BreakVC
open FStar.Tactics.V2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "FStar.Pure.BreakVC.fs... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures Prims.pure_wp_monotonic Prims.unit FStar.Pure.BreakVC.break_wp') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.pure_wp_monotonic",
"FStar.Pure.BreakVC.break_wp'",
"FStar.Tactics.V2.Derived.l_to_r",
"Prims.Cons",
"FStar.Tactics.NamedView.term",
"Prims.Nil",
"FStar.Stubs.Tactics.V2.Builtins.norm",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.... | [] | false | false | true | false | false | let mono_lem () : Lemma (pure_wp_monotonic unit break_wp') =
| FStar.Tactics.Effect.assert_by_tactic (pure_wp_monotonic unit break_wp')
(fun _ ->
();
norm [delta];
l_to_r [`spinoff_eq]) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.array_literal_inv | val array_literal_inv:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
f: (i: US.t{US.v i < US.v n} -> a) ->
i: Loops.nat_at_most n ->
Seq.seq a
-> vprop | val array_literal_inv:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
f: (i: US.t{US.v i < US.v n} -> a) ->
i: Loops.nat_at_most n ->
Seq.seq a
-> vprop | let array_literal_inv
(#a:Type0)
(n:US.t)
(arr:A.array a)
(f:(i:US.t{US.v i < US.v n} -> a))
(i:Loops.nat_at_most n)
: Seq.seq a -> vprop
= fun s ->
A.pts_to arr full_perm s
`star`
pure (array_literal_inv_pure n f i s) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 54,
"start_col": 0,
"start_line": 44
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
arr: Steel.ST.Array.array a ->
f: (i: FStar.SizeT.t{FStar.SizeT.v i < FStar.SizeT.v n} -> a) ->
i: Steel.ST.Loops.nat_at_most n ->
_: FStar.Seq.Base.seq a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Steel.ST.Array.array",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.SizeT.v",
"Steel.ST.Loops.nat_at_most",
"FStar.Seq.Base.seq",
"Steel.Effect.Common.star",
"Steel.ST.Array.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.ST.Util.pure",
"Steel.ST.Array.Util.array_literal_... | [] | false | false | false | false | false | let array_literal_inv
(#a: Type0)
(n: US.t)
(arr: A.array a)
(f: (i: US.t{US.v i < US.v n} -> a))
(i: Loops.nat_at_most n)
: Seq.seq a -> vprop =
| fun s -> (A.pts_to arr full_perm s) `star` (pure (array_literal_inv_pure n f i s)) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall_pure_inv_b | val forall_pure_inv_b:
#a: Type0 ->
n: US.t ->
p: (a -> bool) ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
i: US.t ->
b: bool
-> prop | val forall_pure_inv_b:
#a: Type0 ->
n: US.t ->
p: (a -> bool) ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
i: US.t ->
b: bool
-> prop | let forall_pure_inv_b
(#a:Type0)
(n:US.t)
(p:a -> bool)
(s:Seq.seq a)
(_:squash (Seq.length s == US.v n))
(i:US.t)
(b:bool)
: prop
= b == (i `US.lt` n && p (Seq.index s (US.v i))) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 50,
"end_line": 124,
"start_col": 0,
"start_line": 115
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
p: (_: a -> Prims.bool) ->
s: FStar.Seq.Base.seq a ->
_: Prims.squash (FStar.Seq.Base.length s == FStar.SizeT.v n) ->
i: FStar.SizeT.t ->
b: Prims.bool
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Prims.op_AmpAmp",
"FStar.SizeT.lt",
"FStar.Seq.Base.index",
"Prims.prop"
] | [] | false | false | false | false | true | let forall_pure_inv_b
(#a: Type0)
(n: US.t)
(p: (a -> bool))
(s: Seq.seq a)
(_: squash (Seq.length s == US.v n))
(i: US.t)
(b: bool)
: prop =
| b == (i `US.lt` n && p (Seq.index s (US.v i))) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall_pred | val forall_pred:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
p: (a -> bool) ->
r: R.ref US.t ->
perm: perm ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
b: bool ->
US.t
-> vprop | val forall_pred:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
p: (a -> bool) ->
r: R.ref US.t ->
perm: perm ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
b: bool ->
US.t
-> vprop | let forall_pred
(#a:Type0)
(n:US.t)
(arr:A.array a)
(p:a -> bool)
(r:R.ref US.t)
(perm:perm)
(s:Seq.seq a)
(_:squash (Seq.length s == US.v n))
(b:bool)
: US.t -> vprop
= fun i ->
A.pts_to arr perm s
`star`
R.pts_to r full_perm i
`star`
pure (forall_pure_inv n p s () i)
... | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 145,
"start_col": 0,
"start_line": 127
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
arr: Steel.ST.Array.array a ->
p: (_: a -> Prims.bool) ->
r: Steel.ST.Reference.ref FStar.SizeT.t ->
perm: Steel.FractionalPermission.perm ->
s: FStar.Seq.Base.seq a ->
_: Prims.squash (FStar.Seq.Base.length s == FStar.SizeT.v n) ->
b: Prims.bool ->
_: FStar.Size... | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Steel.ST.Array.array",
"Prims.bool",
"Steel.ST.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Steel.Effect.Common.star",
"Steel.ST.Array.pts_to",
"Steel.ST.Refer... | [] | false | false | false | false | false | let forall_pred
(#a: Type0)
(n: US.t)
(arr: A.array a)
(p: (a -> bool))
(r: R.ref US.t)
(perm: perm)
(s: Seq.seq a)
(_: squash (Seq.length s == US.v n))
(b: bool)
: US.t -> vprop =
| fun i ->
(((A.pts_to arr perm s) `star` (R.pts_to r full_perm i))
`star`
(pure (forall_pure_inv n p s () i)))
`star`
(pure (forall_pure_inv_b n p s () i b)) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall2_pure_inv_b | val forall2_pure_inv_b:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
p: (a -> b -> bool) ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
i: US.t ->
g: bool
-> prop | val forall2_pure_inv_b:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
p: (a -> b -> bool) ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
i: US.t ->
g: bool
-> prop | let forall2_pure_inv_b
(#a #b:Type0)
(n:US.t)
(p:a -> b -> bool)
(s0:Seq.seq a)
(s1:Seq.seq b)
(_:squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
(i:US.t)
(g:bool)
: prop
= g == (i `US.lt` n && p (Seq.index s0 (US.v i)) (Seq.index s1 (US.v i))) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 75,
"end_line": 289,
"start_col": 0,
"start_line": 279
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
p: (_: a -> _: b -> Prims.bool) ->
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq b ->
_:
Prims.squash (FStar.Seq.Base.length s0 == FStar.SizeT.v n /\
FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1) ->
i: FStar.SizeT.t ->
g: Prims.bool
-> Prim... | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Prims.op_AmpAmp",
"FStar.SizeT.lt",
"FStar.Seq.Base.index",
"Prims.prop"
] | [] | false | false | false | false | true | let forall2_pure_inv_b
(#a: Type0)
(#b: Type0)
(n: US.t)
(p: (a -> b -> bool))
(s0: Seq.seq a)
(s1: Seq.seq b)
(_: squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
(i: US.t)
(g: bool)
: prop =
| g == (i `US.lt` n && p (Seq.index s0 (US.v i)) (Seq.index s1 (US.v i))) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall_pure_inv | val forall_pure_inv:
#a: Type0 ->
n: US.t ->
p: (a -> bool) ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
i: US.t
-> prop | val forall_pure_inv:
#a: Type0 ->
n: US.t ->
p: (a -> bool) ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
i: US.t
-> prop | let forall_pure_inv
(#a:Type0)
(n:US.t)
(p:a -> bool)
(s:Seq.seq a)
(_:squash (Seq.length s == US.v n))
(i:US.t)
: prop
= i `US.lte` n /\ (forall (j:nat). j < US.v i ==> p (Seq.index s j)) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 70,
"end_line": 113,
"start_col": 0,
"start_line": 105
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
p: (_: a -> Prims.bool) ->
s: FStar.Seq.Base.seq a ->
_: Prims.squash (FStar.Seq.Base.length s == FStar.SizeT.v n) ->
i: FStar.SizeT.t
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Prims.l_and",
"Prims.b2t",
"FStar.SizeT.lte",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Prims.prop"
] | [] | false | false | false | false | true | let forall_pure_inv
(#a: Type0)
(n: US.t)
(p: (a -> bool))
(s: Seq.seq a)
(_: squash (Seq.length s == US.v n))
(i: US.t)
: prop =
| i `US.lte` n /\ (forall (j: nat). j < US.v i ==> p (Seq.index s j)) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall2_inv | val forall2_inv:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
a0: A.array a ->
a1: A.array b ->
p: (a -> b -> bool) ->
r: R.ref US.t ->
p0: perm ->
p1: perm ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
bool
-> vp... | val forall2_inv:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
a0: A.array a ->
a1: A.array b ->
p: (a -> b -> bool) ->
r: R.ref US.t ->
p0: perm ->
p1: perm ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
bool
-> vp... | let forall2_inv
(#a #b:Type0)
(n:US.t)
(a0:A.array a)
(a1:A.array b)
(p:a -> b -> bool)
(r:R.ref US.t)
(p0 p1:perm)
(s0:Seq.seq a)
(s1:Seq.seq b)
(_:squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
: bool -> vprop
= fun g -> exists_ (forall2_pred n a0 a1 p r p0 p1 s0 s1 () g) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 64,
"end_line": 329,
"start_col": 0,
"start_line": 317
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
a0: Steel.ST.Array.array a ->
a1: Steel.ST.Array.array b ->
p: (_: a -> _: b -> Prims.bool) ->
r: Steel.ST.Reference.ref FStar.SizeT.t ->
p0: Steel.FractionalPermission.perm ->
p1: Steel.FractionalPermission.perm ->
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.... | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Steel.ST.Array.array",
"Prims.bool",
"Steel.ST.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Steel.ST.Util.exists_",
"Steel.ST.Array.Util.forall2... | [] | false | false | false | false | false | let forall2_inv
(#a: Type0)
(#b: Type0)
(n: US.t)
(a0: A.array a)
(a1: A.array b)
(p: (a -> b -> bool))
(r: R.ref US.t)
(p0: perm)
(p1: perm)
(s0: Seq.seq a)
(s1: Seq.seq b)
(_: squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
... | fun g -> exists_ (forall2_pred n a0 a1 p r p0 p1 s0 s1 () g) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall2_pure_inv | val forall2_pure_inv:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
p: (a -> b -> bool) ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
i: US.t
-> prop | val forall2_pure_inv:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
p: (a -> b -> bool) ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
i: US.t
-> prop | let forall2_pure_inv
(#a #b:Type0)
(n:US.t)
(p:a -> b -> bool)
(s0:Seq.seq a)
(s1:Seq.seq b)
(_:squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
(i:US.t)
: prop
= i `US.lte` n /\ (forall (j:nat). j < US.v i ==> p (Seq.index s0 j) (Seq.index s1 j)) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 88,
"end_line": 277,
"start_col": 0,
"start_line": 268
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
p: (_: a -> _: b -> Prims.bool) ->
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.seq b ->
_:
Prims.squash (FStar.Seq.Base.length s0 == FStar.SizeT.v n /\
FStar.Seq.Base.length s0 == FStar.Seq.Base.length s1) ->
i: FStar.SizeT.t
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Prims.b2t",
"FStar.SizeT.lte",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Prims.prop"
] | [] | false | false | false | false | true | let forall2_pure_inv
(#a: Type0)
(#b: Type0)
(n: US.t)
(p: (a -> b -> bool))
(s0: Seq.seq a)
(s1: Seq.seq b)
(_: squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
(i: US.t)
: prop =
| i `US.lte` n /\ (forall (j: nat). j < US.v i ==> p (Seq.index s0 j) (Seq.index s1 j)) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall_inv | val forall_inv:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
p: (a -> bool) ->
r: R.ref US.t ->
perm: perm ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
bool
-> vprop | val forall_inv:
#a: Type0 ->
n: US.t ->
arr: A.array a ->
p: (a -> bool) ->
r: R.ref US.t ->
perm: perm ->
s: Seq.seq a ->
squash (Seq.length s == US.v n) ->
bool
-> vprop | let forall_inv
(#a:Type0)
(n:US.t)
(arr:A.array a)
(p:a -> bool)
(r:R.ref US.t)
(perm:perm)
(s:Seq.seq a)
(_:squash (Seq.length s == US.v n))
: bool -> vprop
= fun b -> exists_ (forall_pred n arr p r perm s () b) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 56,
"end_line": 158,
"start_col": 0,
"start_line": 148
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
arr: Steel.ST.Array.array a ->
p: (_: a -> Prims.bool) ->
r: Steel.ST.Reference.ref FStar.SizeT.t ->
perm: Steel.FractionalPermission.perm ->
s: FStar.Seq.Base.seq a ->
_: Prims.squash (FStar.Seq.Base.length s == FStar.SizeT.v n) ->
_: Prims.bool
-> Steel.Effect.Co... | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Steel.ST.Array.array",
"Prims.bool",
"Steel.ST.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Steel.ST.Util.exists_",
"Steel.ST.Array.Util.forall_pred",
"Steel.E... | [] | false | false | false | false | false | let forall_inv
(#a: Type0)
(n: US.t)
(arr: A.array a)
(p: (a -> bool))
(r: R.ref US.t)
(perm: perm)
(s: Seq.seq a)
(_: squash (Seq.length s == US.v n))
: bool -> vprop =
| fun b -> exists_ (forall_pred n arr p r perm s () b) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.forall2_pred | val forall2_pred:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
a0: A.array a ->
a1: A.array b ->
p: (a -> b -> bool) ->
r: R.ref US.t ->
p0: perm ->
p1: perm ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
g: bool ->
... | val forall2_pred:
#a: Type0 ->
#b: Type0 ->
n: US.t ->
a0: A.array a ->
a1: A.array b ->
p: (a -> b -> bool) ->
r: R.ref US.t ->
p0: perm ->
p1: perm ->
s0: Seq.seq a ->
s1: Seq.seq b ->
squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1) ->
g: bool ->
... | let forall2_pred
(#a #b:Type0)
(n:US.t)
(a0:A.array a)
(a1:A.array b)
(p:a -> b -> bool)
(r:R.ref US.t)
(p0 p1:perm)
(s0:Seq.seq a)
(s1:Seq.seq b)
(_:squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
(g:bool)
: US.t -> vprop
= fun i ->
A.pts_to a0 p0 s0
`star`
A... | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 46,
"end_line": 314,
"start_col": 0,
"start_line": 292
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
a0: Steel.ST.Array.array a ->
a1: Steel.ST.Array.array b ->
p: (_: a -> _: b -> Prims.bool) ->
r: Steel.ST.Reference.ref FStar.SizeT.t ->
p0: Steel.FractionalPermission.perm ->
p1: Steel.FractionalPermission.perm ->
s0: FStar.Seq.Base.seq a ->
s1: FStar.Seq.Base.... | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Steel.ST.Array.array",
"Prims.bool",
"Steel.ST.Reference.ref",
"Steel.FractionalPermission.perm",
"FStar.Seq.Base.seq",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.SizeT.v",
"Steel.Effect.Common.star",
"Steel.ST.Array.pts_to",
... | [] | false | false | false | false | false | let forall2_pred
(#a: Type0)
(#b: Type0)
(n: US.t)
(a0: A.array a)
(a1: A.array b)
(p: (a -> b -> bool))
(r: R.ref US.t)
(p0: perm)
(p1: perm)
(s0: Seq.seq a)
(s1: Seq.seq b)
(_: squash (Seq.length s0 == US.v n /\ Seq.length s0 == Seq.length s1))
... | fun i ->
((((A.pts_to a0 p0 s0) `star` (A.pts_to a1 p1 s1)) `star` (R.pts_to r full_perm i))
`star`
(pure (forall2_pure_inv n p s0 s1 () i)))
`star`
(pure (forall2_pure_inv_b n p s0 s1 () i g)) | false |
Steel.ST.Array.Util.fst | Steel.ST.Array.Util.array_literal_inv_pure | val array_literal_inv_pure
(#a: Type0)
(n: US.t)
(f: (i: US.t{US.v i < US.v n} -> a))
(i: Loops.nat_at_most n)
(s: Seq.seq a)
: prop | val array_literal_inv_pure
(#a: Type0)
(n: US.t)
(f: (i: US.t{US.v i < US.v n} -> a))
(i: Loops.nat_at_most n)
(s: Seq.seq a)
: prop | let array_literal_inv_pure
(#a:Type0)
(n:US.t)
(f:(i:US.t{US.v i < US.v n} -> a))
(i:Loops.nat_at_most n)
(s:Seq.seq a)
: prop
= forall (j:nat).
(j < i /\ j < Seq.length s) ==> Seq.index s j == f (US.uint_to_t j) | {
"file_name": "lib/steel/Steel.ST.Array.Util.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 73,
"end_line": 41,
"start_col": 0,
"start_line": 33
} | (*
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": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.Effect.fsti.checked",
"Steel.ST.Array.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.che... | [
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": true,
"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 |
n: FStar.SizeT.t ->
f: (i: FStar.SizeT.t{FStar.SizeT.v i < FStar.SizeT.v n} -> a) ->
i: Steel.ST.Loops.nat_at_most n ->
s: FStar.Seq.Base.seq a
-> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"FStar.SizeT.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.SizeT.v",
"Steel.ST.Loops.nat_at_most",
"FStar.Seq.Base.seq",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.l_and",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.SizeT.uint_to_t",
"Prims.prop"
] | [] | false | false | false | false | true | let array_literal_inv_pure
(#a: Type0)
(n: US.t)
(f: (i: US.t{US.v i < US.v n} -> a))
(i: Loops.nat_at_most n)
(s: Seq.seq a)
: prop =
| forall (j: nat). (j < i /\ j < Seq.length s) ==> Seq.index s j == f (US.uint_to_t j) | false |
Wasm11.fst | Wasm11.main | val main: Prims.unit -> SteelT Int32.t emp (fun _ -> emp) | val main: Prims.unit -> SteelT Int32.t emp (fun _ -> emp) | let main () : SteelT Int32.t emp (fun _ -> emp) =
let res1 = test1 () in
let res2 = test2 () in
if res1 && res2 then 0l else 1l | {
"file_name": "share/steel/tests/krml/Wasm11.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 33,
"end_line": 54,
"start_col": 0,
"start_line": 51
} | module Wasm11
open FStar.SizeT
open FStar.PtrdiffT
open FStar.UInt64
open Steel.Effect.Atomic
open Steel.Effect
open Steel.Array
(* WASM tests for pointer subtraction *)
let test1 () : SteelT bool emp (fun _ -> emp) =
let r = malloc 0uL 8sz in
ghost_split r 4sz;
let r1 = split_l r 4sz in
let r2 = split_r r 4... | {
"checked_file": "/",
"dependencies": [
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"Steel.Array.fsti.checked",
"prims.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt16.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Ptr... | [
{
"abbrev": false,
"full_module": "Steel.Array",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> Steel.Effect.SteelT FStar.Int32.t | Steel.Effect.SteelT | [] | [] | [
"Prims.unit",
"Prims.op_AmpAmp",
"FStar.Int32.__int_to_t",
"Prims.bool",
"FStar.Int32.t",
"Wasm11.test2",
"Wasm11.test1",
"Steel.Effect.Common.emp",
"Steel.Effect.Common.vprop"
] | [] | false | true | false | false | false | let main () : SteelT Int32.t emp (fun _ -> emp) =
| let res1 = test1 () in
let res2 = test2 () in
if res1 && res2 then 0l else 1l | false |
CQueue.fst | CQueue.elim_queue_head | val elim_queue_head
(#opened: _)
(#a: Type)
(x: t a)
(l: Ghost.erased (list a))
: SteelGhost (Ghost.erased (ccell_ptrvalue a)) opened
(queue_head x l)
(fun hd -> vptr (cllist_head x) `star` llist_fragment_head l (cllist_head x) hd `star` vptr (cllist_tail x))
(fun _ -> True)
(fun _ hd h -> (
... | val elim_queue_head
(#opened: _)
(#a: Type)
(x: t a)
(l: Ghost.erased (list a))
: SteelGhost (Ghost.erased (ccell_ptrvalue a)) opened
(queue_head x l)
(fun hd -> vptr (cllist_head x) `star` llist_fragment_head l (cllist_head x) hd `star` vptr (cllist_tail x))
(fun _ -> True)
(fun _ hd h -> (
... | let elim_queue_head
#_ #a x l
=
let hd = elim_vdep
(vptr (cllist_head x))
(queue_head_dep2 x l)
in
let ptl = elim_vdep
(llist_fragment_head l (cllist_head x) hd)
(queue_head_dep1 x l hd)
in
elim_vrefine
(vptr (cllist_tail x))
(queue_head_refine x l hd ptl);
hd | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 4,
"end_line": 1257,
"start_col": 0,
"start_line": 1243
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source... | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: CQueue.t a -> l: FStar.Ghost.erased (Prims.list a)
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased (CQueue.Cell.ccell_ptrvalue a)) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"CQueue.t",
"FStar.Ghost.erased",
"Prims.list",
"CQueue.Cell.ccell_ptrvalue",
"Prims.unit",
"Steel.Effect.Atomic.elim_vrefine",
"Steel.Reference.vptr",
"Steel.Reference.ref",
"CQueue.LList.cllist_tail",
"CQueue.queue_head_refine",
"FStar.Ghost.reveal",
"Steel.Effect.Co... | [] | false | true | false | false | false | let elim_queue_head #_ #a x l =
| let hd = elim_vdep (vptr (cllist_head x)) (queue_head_dep2 x l) in
let ptl = elim_vdep (llist_fragment_head l (cllist_head x) hd) (queue_head_dep1 x l hd) in
elim_vrefine (vptr (cllist_tail x)) (queue_head_refine x l hd ptl);
hd | false |
Steel.ST.Array.fst | Steel.ST.Array.pts_to_range_split | val pts_to_range_split
(#opened: _)
(#elt: Type0)
(#p: P.perm)
(#s: Seq.seq elt)
(a: array elt)
(i m j: nat)
: STGhost unit opened
(pts_to_range a i j p s)
(fun _ -> exists_ (fun s1 -> exists_ (fun s2 ->
pts_to_range a i m p s1 `star`
pts_to_range a m j p s2 `star`
pure (
i... | val pts_to_range_split
(#opened: _)
(#elt: Type0)
(#p: P.perm)
(#s: Seq.seq elt)
(a: array elt)
(i m j: nat)
: STGhost unit opened
(pts_to_range a i j p s)
(fun _ -> exists_ (fun s1 -> exists_ (fun s2 ->
pts_to_range a i m p s1 `star`
pts_to_range a m j p s2 `star`
pure (
i... | let pts_to_range_split
#_ #_ #p #s a i m j
= length_fits a;
pts_to_range_prop a i j p s;
let a' = pts_to_range_elim' a i j p s in
let mi = US.uint_to_t (m - i) in
ptr_shift_add (ptr_of a) (US.uint_to_t i) mi;
let _ = ghost_split a' mi in
pts_to_range_intro' a m j p (split_r a' mi) _;
pts_to_range_intro'... | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 9,
"end_line": 645,
"start_col": 0,
"start_line": 635
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law ... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.che... | [
{
"abbrev": true,
"full_module": "Steel.ST.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_modul... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Steel.ST.Array.array elt -> i: Prims.nat -> m: Prims.nat -> j: Prims.nat
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Seq.Base.seq",
"Steel.ST.Array.array",
"Prims.nat",
"Steel.ST.Util.noop",
"Prims.unit",
"Steel.ST.Array.pts_to_range_intro'",
"Steel.ST.Array.split_l",
"FStar.Ghost.reveal",
"FStar.Ghost.hide",
"FStar.SizeT.t",
"FStar.Seq.Base.... | [] | false | true | false | false | false | let pts_to_range_split #_ #_ #p #s a i m j =
| length_fits a;
pts_to_range_prop a i j p s;
let a' = pts_to_range_elim' a i j p s in
let mi = US.uint_to_t (m - i) in
ptr_shift_add (ptr_of a) (US.uint_to_t i) mi;
let _ = ghost_split a' mi in
pts_to_range_intro' a m j p (split_r a' mi) _;
pts_to_range_intro' a i m p (split_l a' mi) _;
noop () | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.bv128_64_64 | val bv128_64_64: x1:bv_t 64 -> x0:bv_t 64 -> Tot (bv_t 128) | val bv128_64_64: x1:bv_t 64 -> x0:bv_t 64 -> Tot (bv_t 128) | let bv128_64_64 x0 x1 = bvor (bvshl (bv_uext #64 #64 x1) 64) (bv_uext #64 #64 x0) | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 77,
"start_col": 0,
"start_line": 77
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"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 | x1: FStar.BV.bv_t 64 -> x0: FStar.BV.bv_t 64 -> FStar.BV.bv_t 128 | Prims.Tot | [
"total"
] | [] | [
"FStar.BV.bv_t",
"FStar.BV.bvor",
"FStar.BV.bvshl",
"FStar.BV.bv_uext"
] | [] | false | false | false | false | false | let bv128_64_64 x0 x1 =
| bvor (bvshl (bv_uext #64 #64 x1) 64) (bv_uext #64 #64 x0) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_and_commutes | val lemma_and_commutes: x:uint_t 64 -> y:uint_t 64 ->
Lemma (logand #64 x y == logand #64 y x) | val lemma_and_commutes: x:uint_t 64 -> y:uint_t 64 ->
Lemma (logand #64 x y == logand #64 y x) | let lemma_and_commutes x y =
assert_by_tactic
(logand #64 x y == logand #64 y x)
bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 54,
"start_col": 0,
"start_line": 51
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64 -> y: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.logand x y == FStar.UInt.logand y x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_and_commutes x y =
| assert_by_tactic (logand #64 x y == logand #64 y x) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.uint_to_nat | val uint_to_nat (#n: nat) (x: uint_t n) : r: nat{r = x} | val uint_to_nat (#n: nat) (x: uint_t n) : r: nat{r = x} | let uint_to_nat (#n:nat) (x:uint_t n) : r:nat{r = x} =
assert (x < pow2 n);
modulo_lemma x (pow2 n);
x | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 2,
"end_line": 82,
"start_col": 7,
"start_line": 79
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t n -> r: Prims.nat{r = x} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt.uint_t",
"Prims.unit",
"FStar.Math.Lemmas.modulo_lemma",
"Prims.pow2",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size"
] | [] | false | false | false | false | false | let uint_to_nat (#n: nat) (x: uint_t n) : r: nat{r = x} =
| assert (x < pow2 n);
modulo_lemma x (pow2 n);
x | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bv128_64_64_and_helper | val lemma_bv128_64_64_and_helper: x:bv_t 128 -> x0:bv_t 64 -> x1:bv_t 64 ->
y:bv_t 128 -> y0:bv_t 64 -> y1:bv_t 64 ->
z:bv_t 128 -> z0:bv_t 64 -> z1:bv_t 64 ->
Lemma (requires (z0 == bvand #64 x0 y0 /\
z1 == bvand #64 x1 y1 /\
x == bvor #128 (bvshl #128 (bv_uext #64 #64 x1) 6... | val lemma_bv128_64_64_and_helper: x:bv_t 128 -> x0:bv_t 64 -> x1:bv_t 64 ->
y:bv_t 128 -> y0:bv_t 64 -> y1:bv_t 64 ->
z:bv_t 128 -> z0:bv_t 64 -> z1:bv_t 64 ->
Lemma (requires (z0 == bvand #64 x0 y0 /\
z1 == bvand #64 x1 y1 /\
x == bvor #128 (bvshl #128 (bv_uext #64 #64 x1) 6... | let lemma_bv128_64_64_and_helper x x0 x1 y y0 y1 z z0 z1 =
lemma_bv128_64_64_and_helper' x0 x1 y0 y1;
assert_by_tactic (z == bvand #128 x y)
(fun () -> destruct_conj ();
rewrite_eqs_from_context ()) | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 75,
"start_col": 0,
"start_line": 71
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: FStar.BV.bv_t 128 ->
x0: FStar.BV.bv_t 64 ->
x1: FStar.BV.bv_t 64 ->
y: FStar.BV.bv_t 128 ->
y0: FStar.BV.bv_t 64 ->
y1: FStar.BV.bv_t 64 ->
z: FStar.BV.bv_t 128 ->
z0: FStar.BV.bv_t 64 ->
z1: FStar.BV.bv_t 64
-> FStar.Pervasives.Lemma
(requires
z0 == FStar.BV.bva... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.BV.bv_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BV.bvand",
"Prims.unit",
"FStar.Tactics.V1.Derived.rewrite_eqs_from_context",
"Vale.Lib.Tactics.destruct_conj",
"Vale.Poly1305.Bitvectors.lemma_bv128_64_64_and_helper'"
] | [] | false | false | true | false | false | let lemma_bv128_64_64_and_helper x x0 x1 y y0 y1 z z0 z1 =
| lemma_bv128_64_64_and_helper' x0 x1 y0 y1;
assert_by_tactic (z == bvand #128 x y)
(fun () ->
destruct_conj ();
rewrite_eqs_from_context ()) | false |
Vale.SHA.PPC64LE.Rounds.Core.fst | Vale.SHA.PPC64LE.Rounds.Core.va_lemma_Loop_rounds_0_63_body | val va_lemma_Loop_rounds_0_63_body : va_b0:va_code -> va_s0:va_state -> i:nat ->
msg:va_operand_vec_opr -> a_vec:va_operand_vec_opr -> b_vec:va_operand_vec_opr ->
c_vec:va_operand_vec_opr -> d_vec:va_operand_vec_opr -> e_vec:va_operand_vec_opr ->
f_vec:va_operand_vec_opr -> g_vec:va_operand_vec_opr -> h_vec:va_op... | val va_lemma_Loop_rounds_0_63_body : va_b0:va_code -> va_s0:va_state -> i:nat ->
msg:va_operand_vec_opr -> a_vec:va_operand_vec_opr -> b_vec:va_operand_vec_opr ->
c_vec:va_operand_vec_opr -> d_vec:va_operand_vec_opr -> e_vec:va_operand_vec_opr ->
f_vec:va_operand_vec_opr -> g_vec:va_operand_vec_opr -> h_vec:va_op... | let va_lemma_Loop_rounds_0_63_body va_b0 va_s0 i msg a_vec b_vec c_vec d_vec e_vec f_vec g_vec
h_vec k_b block hash_orig =
let (va_mods:va_mods_t) = [va_Mod_vec 26; va_Mod_vec 25; va_Mod_ok; va_mod_vec_opr h_vec;
va_mod_vec_opr g_vec; va_mod_vec_opr d_vec] in
let va_qc = va_qcode_Loop_rounds_0_63_body va_mods... | {
"file_name": "obj/Vale.SHA.PPC64LE.Rounds.Core.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 16,
"end_line": 612,
"start_col": 0,
"start_line": 523
} | module Vale.SHA.PPC64LE.Rounds.Core
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.PPC64LE.Machine_s
open Vale.PPC64LE.Memory
open Vale.PPC64LE.Stack_i
open Vale.PPC64LE.State
open Vale.PPC64LE.Decls
open... | {
"checked_file": "/",
"dependencies": [
"Vale.SHA2.Wrapper.fsti.checked",
"Vale.SHA.PPC64LE.SHA_helpers.fsti.checked",
"Vale.PPC64LE.State.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.QuickCodes.fsti.checked",
"Vale.PPC64LE.QuickCode.fst.checked",
"Vale.PPC64LE.Memo... | [
{
"abbrev": false,
"full_module": "Vale.SHA2.Wrapper",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_b0: Vale.PPC64LE.Decls.va_code ->
va_s0: Vale.PPC64LE.Decls.va_state ->
i: Prims.nat ->
msg: Vale.PPC64LE.Decls.va_operand_vec_opr ->
a_vec: Vale.PPC64LE.Decls.va_operand_vec_opr ->
b_vec: Vale.PPC64LE.Decls.va_operand_vec_opr ->
c_vec: Vale.PPC64LE.Decls.va_operand_vec_opr ->
d_vec:... | Prims.Ghost | [] | [] | [
"Vale.PPC64LE.Decls.va_code",
"Vale.PPC64LE.Decls.va_state",
"Prims.nat",
"Vale.PPC64LE.Decls.va_operand_vec_opr",
"Vale.PPC64LE.Memory.buffer128",
"Vale.SHA.PPC64LE.SHA_helpers.block_w",
"Vale.SHA.PPC64LE.SHA_helpers.hash256",
"Vale.PPC64LE.QuickCodes.fuel",
"Prims.unit",
"FStar.Pervasives.Native... | [] | false | false | false | false | false | let va_lemma_Loop_rounds_0_63_body
va_b0
va_s0
i
msg
a_vec
b_vec
c_vec
d_vec
e_vec
f_vec
g_vec
h_vec
k_b
block
hash_orig
=
| let va_mods:va_mods_t =
[
va_Mod_vec 26;
va_Mod_vec 25;
va_Mod_ok;
va_mod_vec_opr h_vec;
va_mod_vec_opr g_vec;
va_mod_vec_opr d_vec
]
in
let va_qc =
va_qcode_Loop_rounds_0_63_body va_mods i msg a_vec b_vec c_vec d_vec e_vec f_vec g_vec h_vec k_b
block hash_orig
in
let va_sM, va_fM, va_... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.uint_ext | val uint_ext (#n: nat) (#m: nat{n <= m}) (x: uint_t n)
: r: (uint_t m){uint_to_nat r = uint_to_nat x} | val uint_ext (#n: nat) (#m: nat{n <= m}) (x: uint_t n)
: r: (uint_t m){uint_to_nat r = uint_to_nat x} | let uint_ext (#n : nat) (#m : nat{n <= m}) (x : uint_t n) : r:(uint_t m){uint_to_nat r = uint_to_nat x} =
assert_norm(fits x n);
pow2_le_compat m n;
assert_norm(fits x m);
modulo_lemma x (pow2 m);
to_uint_t m x | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 89,
"start_col": 0,
"start_line": 84
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t n
-> r:
FStar.UInt.uint_t m
{Vale.Poly1305.Bitvectors.uint_to_nat r = Vale.Poly1305.Bitvectors.uint_to_nat x} | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt.uint_t",
"FStar.UInt.to_uint_t",
"Prims.unit",
"FStar.Math.Lemmas.modulo_lemma",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"FStar.UInt.fits",
"FStar.Math.Lemmas.pow2_le_compat",
"Prims.op_Equality",
"Prims.l_or",
"Prims.... | [] | false | false | false | false | false | let uint_ext (#n: nat) (#m: nat{n <= m}) (x: uint_t n)
: r: (uint_t m){uint_to_nat r = uint_to_nat x} =
| assert_norm (fits x n);
pow2_le_compat m n;
assert_norm (fits x m);
modulo_lemma x (pow2 m);
to_uint_t m x | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.mk_one_method | val mk_one_method (proj:string) (np:nat) : Tac unit | val mk_one_method (proj:string) (np:nat) : Tac unit | let mk_one_method (proj:string) (np:nat) : Tac unit =
debug (fun () -> dump "ENTRY mk_one_method"; "");
let nm = explode_qn proj in
let params = repeatn np (fun () -> let b : binding = intro () in
(binding_to_term b, Q_Implicit)) in
let thing : binding = intro () in
let pr... | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 58,
"start_col": 0,
"start_line": 51
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | proj: Prims.string -> np: Prims.nat -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.string",
"Prims.nat",
"FStar.Tactics.V2.Derived.exact",
"FStar.Reflection.V2.Derived.mk_app",
"FStar.List.Tot.Base.op_At",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.NamedView.term",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"Prims.Cons",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ta... | [] | false | true | false | false | false | let mk_one_method (proj: string) (np: nat) : Tac unit =
| debug (fun () ->
dump "ENTRY mk_one_method";
"");
let nm = explode_qn proj in
let params =
repeatn np
(fun () ->
let b:binding = intro () in
(binding_to_term b, Q_Implicit))
in
let thing:binding = intro () in
let proj = pack (Tv_FVar (pack_fv nm)) in
exact (mk_app proj (params @ [(bind... | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.debug | val debug (f: (unit -> Tac string)) : Tac unit | val debug (f: (unit -> Tac string)) : Tac unit | let debug (f : unit -> Tac string) : Tac unit =
if debugging () then
print (f ()) | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 16,
"end_line": 24,
"start_col": 0,
"start_line": 22
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | f: (_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.string) -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"Prims.string",
"FStar.Stubs.Tactics.V2.Builtins.print",
"Prims.bool",
"FStar.Stubs.Tactics.V2.Builtins.debugging"
] | [] | false | true | false | false | false | let debug (f: (unit -> Tac string)) : Tac unit =
| if debugging () then print (f ()) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lowerUpper128m | val lowerUpper128m (l u: uint_t 64) : uint_t 128 | val lowerUpper128m (l u: uint_t 64) : uint_t 128 | let lowerUpper128m (l:uint_t 64) (u:uint_t 64) : uint_t 128 =
add_hide #128 (mul_hide #128 (uext #64 #64 u) 0x10000000000000000) (uext #64 #64 l) | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 133,
"start_col": 0,
"start_line": 132
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: FStar.UInt.uint_t 64 -> u153: FStar.UInt.uint_t 64 -> FStar.UInt.uint_t 128 | Prims.Tot | [
"total"
] | [] | [
"FStar.UInt.uint_t",
"Vale.Math.Bits.add_hide",
"Vale.Math.Bits.mul_hide",
"Vale.Math.Bits.uext"
] | [] | false | false | false | false | false | let lowerUpper128m (l u: uint_t 64) : uint_t 128 =
| add_hide #128 (mul_hide #128 (uext #64 #64 u) 0x10000000000000000) (uext #64 #64 l) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lowerUpper128b | val lowerUpper128b (l u: bv_t 64) : bv_t 128 | val lowerUpper128b (l u: bv_t 64) : bv_t 128 | let lowerUpper128b (l:bv_t 64) (u:bv_t 64) : bv_t 128 =
b_add #128 (b_mul #128 (b_uext #64 #64 u) 0x10000000000000000) (b_uext #64 #64 l) | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 136,
"start_col": 0,
"start_line": 135
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | l: FStar.BV.bv_t 64 -> u157: FStar.BV.bv_t 64 -> FStar.BV.bv_t 128 | Prims.Tot | [
"total"
] | [] | [
"FStar.BV.bv_t",
"Vale.Math.Bits.b_add",
"Vale.Math.Bits.b_mul",
"Vale.Math.Bits.b_uext"
] | [] | false | false | false | false | false | let lowerUpper128b (l u: bv_t 64) : bv_t 128 =
| b_add #128 (b_mul #128 (b_uext #64 #64 u) 0x10000000000000000) (b_uext #64 #64 l) | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.binder_mk_implicit | val binder_mk_implicit (b: binder) : binder | val binder_mk_implicit (b: binder) : binder | let binder_mk_implicit (b:binder) : binder =
let q =
match b.qual with
| Q_Explicit -> Q_Implicit
| q -> q (* keep Q_Meta as it is *)
in
{ b with qual = q } | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 21,
"end_line": 70,
"start_col": 0,
"start_line": 64
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | b: FStar.Tactics.NamedView.binder -> FStar.Tactics.NamedView.binder | Prims.Tot | [
"total"
] | [] | [
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.Mkbinder",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__uniq",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__ppname",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__sort",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__attrs",
"FStar.... | [] | false | false | false | true | false | let binder_mk_implicit (b: binder) : binder =
| let q =
match b.qual with
| Q_Explicit -> Q_Implicit
| q -> q
in
{ b with qual = q } | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.subst_map | val subst_map (ss: list (namedv * fv)) (r t: term) : Tac term | val subst_map (ss: list (namedv * fv)) (r t: term) : Tac term | let subst_map (ss : list (namedv * fv)) (r:term) (t : term) : Tac term =
let subst = List.Tot.map (fun (x, fv) -> NT (Reflection.V2.pack_namedv x) (mk_e_app (Tv_FVar fv) [r])) ss in
subst_term subst t | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 20,
"end_line": 62,
"start_col": 0,
"start_line": 60
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 |
ss: Prims.list (FStar.Tactics.NamedView.namedv * FStar.Stubs.Reflection.Types.fv) ->
r: FStar.Tactics.NamedView.term ->
t: FStar.Tactics.NamedView.term
-> FStar.Tactics.Effect.Tac FStar.Tactics.NamedView.term | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.NamedView.namedv",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Tactics.NamedView.term",
"FStar.Stubs.Reflection.V2.Builtins.subst_term",
"FStar.Stubs.Syntax.Syntax.subst_elt",
"FStar.List.Tot.Base.map",
"FStar.Stubs.Reflection.V2.Data.name... | [] | false | true | false | false | false | let subst_map (ss: list (namedv * fv)) (r t: term) : Tac term =
| let subst =
List.Tot.map (fun (x, fv) -> NT (Reflection.V2.pack_namedv x) (mk_e_app (Tv_FVar fv) [r])) ss
in
subst_term subst t | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.mk_one_projector | val mk_one_projector (unf:list string) (np:nat) (i:nat) : Tac unit | val mk_one_projector (unf:list string) (np:nat) (i:nat) : Tac unit | let mk_one_projector (unf:list string) (np:nat) (i:nat) : Tac unit =
debug (fun () -> dump "ENTRY mk_one_projector"; "");
let _params = repeatn np intro in
let thing : binding = intro () in
let r = t_destruct thing in
match r with
| [(cons, arity)] -> begin
if (i >= arity) then
fail "proj: bad ind... | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 41,
"end_line": 48,
"start_col": 0,
"start_line": 27
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | unf: Prims.list Prims.string -> np: Prims.nat -> i: Prims.nat -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.list",
"Prims.string",
"Prims.nat",
"FStar.Stubs.Reflection.Types.fv",
"FStar.Tactics.V2.Derived.exact",
"FStar.Tactics.V2.SyntaxCoercions.binding_to_term",
"Prims.unit",
"FStar.Stubs.Tactics.V2.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.iota",
"FStar.... | [] | false | true | false | false | false | let mk_one_projector (unf: list string) (np i: nat) : Tac unit =
| debug (fun () ->
dump "ENTRY mk_one_projector";
"");
let _params = repeatn np intro in
let thing:binding = intro () in
let r = t_destruct thing in
match r with
| [cons, arity] ->
if (i >= arity) then fail "proj: bad index in mk_one_projector";
let _ = repeatn i intro in
let the_b = intro () in
let _... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_shr4 | val lemma_shr4: x:uint_t 64 -> Lemma (shift_right #64 x 4 == udiv #64 x 16)
[SMTPat (shift_right #64 x 4)] | val lemma_shr4: x:uint_t 64 -> Lemma (shift_right #64 x 4 == udiv #64 x 16)
[SMTPat (shift_right #64 x 4)] | let lemma_shr4 x =
assert_by_tactic (shift_right #64 x 4 == udiv #64 x 16) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 22,
"start_col": 0,
"start_line": 21
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.shift_right x 4 == FStar.UInt.udiv x 16)
[SMTPat (FStar.UInt.shift_right x 4)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.shift_right",
"FStar.UInt.udiv",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_shr4 x =
| assert_by_tactic (shift_right #64 x 4 == udiv #64 x 16) bv_tac | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.binder_to_term | val binder_to_term (b: binder) : Tot term | val binder_to_term (b: binder) : Tot term | let binder_to_term (b:binder) : Tot term =
pack (Tv_Var (binder_to_namedv b)) | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 36,
"end_line": 73,
"start_col": 0,
"start_line": 72
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | b: FStar.Tactics.NamedView.binder -> FStar.Tactics.NamedView.term | Prims.Tot | [
"total"
] | [] | [
"FStar.Tactics.NamedView.binder",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.Tv_Var",
"FStar.Tactics.V2.SyntaxCoercions.binder_to_namedv",
"FStar.Tactics.NamedView.term"
] | [] | false | false | false | true | false | let binder_to_term (b: binder) : Tot term =
| pack (Tv_Var (binder_to_namedv b)) | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.binder_argv | val binder_argv (b: binder) : Tot argv | val binder_argv (b: binder) : Tot argv | let binder_argv (b:binder) : Tot argv =
let q =
match b.qual with
| Q_Meta _ -> Q_Implicit
| q -> q
in
(binder_to_term b, q) | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 23,
"end_line": 81,
"start_col": 0,
"start_line": 75
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | b: FStar.Tactics.NamedView.binder -> FStar.Stubs.Reflection.V2.Data.argv | Prims.Tot | [
"total"
] | [] | [
"FStar.Tactics.NamedView.binder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Stubs.Reflection.Types.term",
"FStar.Stubs.Reflection.V2.Data.aqualv",
"FStar.Tactics.MkProjectors.binder_to_term",
"FStar.Tactics.NamedView.__proj__Mkbinder__item__qual",
"FStar.Stubs.Reflection.V2.Data.Q_Implicit",
"FStar.S... | [] | false | false | false | true | false | let binder_argv (b: binder) : Tot argv =
| let q =
match b.qual with
| Q_Meta _ -> Q_Implicit
| q -> q
in
(binder_to_term b, q) | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.embed_int | val embed_int (i: int) : term | val embed_int (i: int) : term | let embed_int (i:int) : term =
let open FStar.Reflection.V2 in
pack_ln (Tv_Const (C_Int i)) | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 30,
"end_line": 91,
"start_col": 0,
"start_line": 89
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | i: Prims.int -> FStar.Tactics.NamedView.term | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Const",
"FStar.Stubs.Reflection.V2.Data.C_Int",
"FStar.Tactics.NamedView.term"
] | [] | false | false | false | true | false | let embed_int (i: int) : term =
| let open FStar.Reflection.V2 in pack_ln (Tv_Const (C_Int i)) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_shr2 | val lemma_shr2: (x:uint_t 64) -> Lemma
((shift_right #64 x 2 == udiv #64 x 4))
[SMTPat (shift_right #64 x 2)] | val lemma_shr2: (x:uint_t 64) -> Lemma
((shift_right #64 x 2 == udiv #64 x 4))
[SMTPat (shift_right #64 x 2)] | let lemma_shr2 x =
assert_by_tactic (shift_right #64 x 2 == udiv #64 x 4) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 19,
"start_col": 0,
"start_line": 18
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.shift_right x 2 == FStar.UInt.udiv x 4)
[SMTPat (FStar.UInt.shift_right x 2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.shift_right",
"FStar.UInt.udiv",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_shr2 x =
| assert_by_tactic (shift_right #64 x 2 == udiv #64 x 4) bv_tac | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.embed_string | val embed_string (s: string) : term | val embed_string (s: string) : term | let embed_string (s:string) : term =
let open FStar.Reflection.V2 in
pack_ln (Tv_Const (C_String s)) | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 95,
"start_col": 0,
"start_line": 93
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | s: Prims.string -> FStar.Tactics.NamedView.term | Prims.Tot | [
"total"
] | [] | [
"Prims.string",
"FStar.Stubs.Reflection.V2.Builtins.pack_ln",
"FStar.Stubs.Reflection.V2.Data.Tv_Const",
"FStar.Stubs.Reflection.V2.Data.C_String",
"FStar.Tactics.NamedView.term"
] | [] | false | false | false | true | false | let embed_string (s: string) : term =
| let open FStar.Reflection.V2 in pack_ln (Tv_Const (C_String s)) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_power2 | val lemma_bytes_power2: unit ->
Lemma (ensures (pow2 0 == 0x1 /\
pow2 8 == 0x100 /\
pow2 16 == 0x10000 /\
pow2 24 == 0x1000000 /\
pow2 32 == 0x100000000 /\
pow2 40 == 0x10000000000 /\
pow2 48 == 0x1000000000000 /\
... | val lemma_bytes_power2: unit ->
Lemma (ensures (pow2 0 == 0x1 /\
pow2 8 == 0x100 /\
pow2 16 == 0x10000 /\
pow2 24 == 0x1000000 /\
pow2 32 == 0x100000000 /\
pow2 40 == 0x10000000000 /\
pow2 48 == 0x1000000000000 /\
... | let lemma_bytes_power2 () =
assert_norm (pow2 0 == 0x1);
assert_norm (pow2 8 == 0x100);
assert_norm (pow2 16 == 0x10000);
assert_norm (pow2 24 == 0x1000000);
assert_norm (pow2 32 == 0x100000000);
assert_norm (pow2 40 == 0x10000000000);
assert_norm (pow2 48 == 0x1000000000000);
assert_norm (pow2 56 == 0x... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 253,
"start_col": 0,
"start_line": 244
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
Prims.pow2 0 == 0x1 /\ Prims.pow2 8 == 0x100 /\ Prims.pow2 16 == 0x10000 /\
Prims.pow2 24 == 0x1000000 /\ Prims.pow2 32 == 0x100000000 /\ Prims.pow2 40 == 0x10000000000 /\
Prims.pow2 48 == 0x1000000000000 /\ Prims.pow2 56 == 0x100000000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.pow2"
] | [] | true | false | true | false | false | let lemma_bytes_power2 () =
| assert_norm (pow2 0 == 0x1);
assert_norm (pow2 8 == 0x100);
assert_norm (pow2 16 == 0x10000);
assert_norm (pow2 24 == 0x1000000);
assert_norm (pow2 32 == 0x100000000);
assert_norm (pow2 40 == 0x10000000000);
assert_norm (pow2 48 == 0x1000000000000);
assert_norm (pow2 56 == 0x100000000000000);
() | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.default_relation | val default_relation (#a: Type u#a) (x1 x2: a) : Type0 | val default_relation (#a: Type u#a) (x1 x2: a) : Type0 | let default_relation (#a: Type u#a) (x1: a) (x2: a) : Type0 = x1 << x2 | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 122,
"start_col": 0,
"start_line": 122
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x1: a -> x2: a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.precedes"
] | [] | false | false | false | true | true | let default_relation (#a: Type u#a) (x1 x2: a) : Type0 =
| x1 << x2 | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.ambient_wfr_lemma | val ambient_wfr_lemma (#a: Type u#a) (wfr: wfr_t a) (x1 x2: a)
: Lemma (requires wfr.relation x1 x2)
(ensures wfr.decreaser x1 << wfr.decreaser x2)
[SMTPat (wfr.decreaser x1); SMTPat (wfr.decreaser x2)] | val ambient_wfr_lemma (#a: Type u#a) (wfr: wfr_t a) (x1 x2: a)
: Lemma (requires wfr.relation x1 x2)
(ensures wfr.decreaser x1 << wfr.decreaser x2)
[SMTPat (wfr.decreaser x1); SMTPat (wfr.decreaser x2)] | let ambient_wfr_lemma (#a: Type u#a) (wfr: wfr_t a) (x1: a) (x2: a)
: Lemma (requires wfr.relation x1 x2)
(ensures wfr.decreaser x1 << wfr.decreaser x2)
[SMTPat (wfr.decreaser x1); SMTPat (wfr.decreaser x2)] =
wfr.proof x1 x2 | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 114,
"start_col": 0,
"start_line": 110
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | wfr: FStar.WellFoundedRelation.wfr_t a -> x1: a -> x2: a
-> FStar.Pervasives.Lemma (requires Mkwfr_t?.relation wfr x1 x2)
(ensures Mkwfr_t?.decreaser wfr x1 << Mkwfr_t?.decreaser wfr x2)
[SMTPat (Mkwfr_t?.decreaser wfr x1); SMTPat (Mkwfr_t?.decreaser wfr x2)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.WellFoundedRelation.wfr_t",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__proof",
"Prims.unit",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__relation",
"Prims.squash",
"Prims.precedes",
"FStar.WellFoundedRelation.acc_classical",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__decreas... | [] | true | false | true | false | false | let ambient_wfr_lemma (#a: Type u#a) (wfr: wfr_t a) (x1 x2: a)
: Lemma (requires wfr.relation x1 x2)
(ensures wfr.decreaser x1 << wfr.decreaser x2)
[SMTPat (wfr.decreaser x1); SMTPat (wfr.decreaser x2)] =
| wfr.proof x1 x2 | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_poly_constants | val lemma_poly_constants: x:uint_t 64 ->
Lemma (logand #64 x 0x0ffffffc0fffffff < 0x1000000000000000 /\
logand #64 x 0x0ffffffc0ffffffc < 0x1000000000000000 /\
mod #64 (logand #64 x 0x0ffffffc0ffffffc) 4 == 0)
[SMTPat (logand #64 x 0x0ffffffc0fffffff);
SMTPat (logand #64 x 0x0ffffffc0ffffffc);
... | val lemma_poly_constants: x:uint_t 64 ->
Lemma (logand #64 x 0x0ffffffc0fffffff < 0x1000000000000000 /\
logand #64 x 0x0ffffffc0ffffffc < 0x1000000000000000 /\
mod #64 (logand #64 x 0x0ffffffc0ffffffc) 4 == 0)
[SMTPat (logand #64 x 0x0ffffffc0fffffff);
SMTPat (logand #64 x 0x0ffffffc0ffffffc);
... | let lemma_poly_constants x =
// using split in this seems to hang execution.
assert_by_tactic
(logand #64 x 0x0ffffffc0fffffff < (0x1000000000000000 <: uint_t 64))
(fun () -> bv_tac_lt 64);
assert_by_tactic
(logand #64 x 0x0ffffffc0ffffffc < (0x1000000000000000 <: uint_t 64))
(fun () -> bv_tac... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 49,
"start_col": 0,
"start_line": 39
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.logand x 0x0ffffffc0fffffff < 0x1000000000000000 /\
FStar.UInt.logand x 0x0ffffffc0ffffffc < 0x1000000000000000 /\
FStar.UInt.mod (FStar.UInt.logand x 0x0ffffffc0ffffffc) 4 == 0)
[
SMTPat (FStar.UInt.loga... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.mod",
"FStar.UInt.logand",
"Prims.unit",
"FStar.Tactics.BV.bv_tac",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Tactics.BV.bv_tac_lt"
] | [] | false | false | true | false | false | let lemma_poly_constants x =
| assert_by_tactic (logand #64 x 0x0ffffffc0fffffff < (0x1000000000000000 <: uint_t 64))
(fun () -> bv_tac_lt 64);
assert_by_tactic (logand #64 x 0x0ffffffc0ffffffc < (0x1000000000000000 <: uint_t 64))
(fun () -> bv_tac_lt 64);
assert_by_tactic (mod #64 (logand #64 x 0x0ffffffc0ffffffc) 4 == (0 <: uint_t 64))
(fun ... | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.empty_relation | val empty_relation (#a: Type u#a) (x1 x2: a) : Type0 | val empty_relation (#a: Type u#a) (x1 x2: a) : Type0 | let empty_relation (#a: Type u#a) (x1: a) (x2: a) : Type0 = False | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 65,
"end_line": 131,
"start_col": 0,
"start_line": 131
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x1: a -> x2: a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_False"
] | [] | false | false | false | true | true | let empty_relation (#a: Type u#a) (x1 x2: a) : Type0 =
| False | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.acc_relation | val acc_relation (#a: Type u#a) (r: (a -> a -> Type0)) (x1 x2: a) : Type0 | val acc_relation (#a: Type u#a) (r: (a -> a -> Type0)) (x1 x2: a) : Type0 | let acc_relation (#a: Type u#a) (r: a -> a -> Type0) (x1: a) (x2: a) : Type0 = exists (p: r x1 x2). True | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 104,
"end_line": 142,
"start_col": 0,
"start_line": 142
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"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: (_: a -> _: a -> Type0) -> x1: a -> x2: a -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.l_Exists",
"Prims.l_True"
] | [] | false | false | false | true | true | let acc_relation (#a: Type u#a) (r: (a -> a -> Type0)) (x1 x2: a) : Type0 =
| exists (p: r x1 x2). True | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.lex_nondep_relation | val lex_nondep_relation
(#a: Type u#a)
(#b: Type u#b)
(wfr_a: wfr_t a)
(wfr_b: wfr_t b)
(xy1 xy2: (a * b))
: Type0 | val lex_nondep_relation
(#a: Type u#a)
(#b: Type u#b)
(wfr_a: wfr_t a)
(wfr_b: wfr_t b)
(xy1 xy2: (a * b))
: Type0 | let lex_nondep_relation (#a: Type u#a) (#b: Type u#b) (wfr_a: wfr_t a) (wfr_b: wfr_t b)
(xy1: a * b) (xy2: a * b)
: Type0 =
let (x1, y1), (x2, y2) = xy1, xy2 in
wfr_a.relation x1 x2 \/ (x1 == x2 /\ wfr_b.relation y1 y2) | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 60,
"end_line": 186,
"start_col": 0,
"start_line": 182
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
wfr_a: FStar.WellFoundedRelation.wfr_t a ->
wfr_b: FStar.WellFoundedRelation.wfr_t b ->
xy1: (a * b) ->
xy2: (a * b)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.WellFoundedRelation.wfr_t",
"FStar.Pervasives.Native.tuple2",
"Prims.l_or",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__relation",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | true | true | let lex_nondep_relation
(#a: Type u#a)
(#b: Type u#b)
(wfr_a: wfr_t a)
(wfr_b: wfr_t b)
(xy1 xy2: a * b)
: Type0 =
| let (x1, y1), (x2, y2) = xy1, xy2 in
wfr_a.relation x1 x2 \/ (x1 == x2 /\ wfr_b.relation y1 y2) | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.list_last | val list_last (#a: _) (xs: list a) : Tac a | val list_last (#a: _) (xs: list a) : Tac a | let rec list_last #a (xs : list a) : Tac a =
match xs with
| [] -> fail "list_last: empty"
| [x] -> x
| _::xs -> list_last xs | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 25,
"end_line": 87,
"start_col": 0,
"start_line": 83
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | xs: Prims.list a -> FStar.Tactics.Effect.Tac a | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.list",
"FStar.Tactics.V2.Derived.fail",
"FStar.Tactics.MkProjectors.list_last"
] | [
"recursion"
] | false | true | false | false | false | let rec list_last #a (xs: list a) : Tac a =
| match xs with
| [] -> fail "list_last: empty"
| [x] -> x
| _ :: xs -> list_last xs | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.bool_relation | val bool_relation (x1 x2: bool) : Type0 | val bool_relation (x1 x2: bool) : Type0 | let bool_relation (x1: bool) (x2: bool) : Type0 = x1 == false /\ x2 == true | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 75,
"end_line": 215,
"start_col": 0,
"start_line": 215
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x1: Prims.bool -> x2: Prims.bool -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.l_and",
"Prims.eq2"
] | [] | false | false | false | true | true | let bool_relation (x1 x2: bool) : Type0 =
| x1 == false /\ x2 == true | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_power2 | val lemma_bytes_shift_power2: y:uint_t 64 ->
Lemma (requires (y < 8))
(ensures (shift_left #64 y 3 < 64 /\
y * 8 == shift_left #64 y 3 /\
pow2 (shift_left #64 y 3) == shift_left #64 1 (shift_left #64 y 3))) | val lemma_bytes_shift_power2: y:uint_t 64 ->
Lemma (requires (y < 8))
(ensures (shift_left #64 y 3 < 64 /\
y * 8 == shift_left #64 y 3 /\
pow2 (shift_left #64 y 3) == shift_left #64 1 (shift_left #64 y 3))) | let lemma_bytes_shift_power2 y =
(match y with
| 0 ->
lemma_bytes_shift_constants0 ()
| 1 ->
lemma_bytes_shift_constants1 ()
| 2 ->
lemma_bytes_shift_constants2 ()
| 3 ->
lemma_bytes_shift_constants3 ()
| 4 ->
lemma_bytes_shift_constants4 ()
| 5 ->
lemma_bytes_shift_constants5 ()
... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 274,
"start_col": 0,
"start_line": 255
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"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 | y: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (requires y < 8)
(ensures
FStar.UInt.shift_left y 3 < 64 /\ y * 8 == FStar.UInt.shift_left y 3 /\
Prims.pow2 (FStar.UInt.shift_left y 3) ==
FStar.UInt.shift_left 1 (FStar.UInt.shift_left y 3)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"Vale.Poly1305.Bitvectors.lemma_bytes_power2",
"Prims.unit",
"Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants0",
"Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants1",
"Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants2",
"Vale.Poly1305.Bitvectors.lemma_bytes_shift_constan... | [] | false | false | true | false | false | let lemma_bytes_shift_power2 y =
| (match y with
| 0 -> lemma_bytes_shift_constants0 ()
| 1 -> lemma_bytes_shift_constants1 ()
| 2 -> lemma_bytes_shift_constants2 ()
| 3 -> lemma_bytes_shift_constants3 ()
| 4 -> lemma_bytes_shift_constants4 ()
| 5 -> lemma_bytes_shift_constants5 ()
| 6 -> lemma_bytes_shift_constants6 ()
| 7 -> lemma_byte... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_and_constants | val lemma_and_constants: x:uint_t 64 ->
Lemma (logand #64 x 0 == 0 /\ logand #64 x 0xffffffffffffffff == x)
[SMTPat (logand #64 x 0); SMTPat (logand #64 x 0xffffffffffffffff)] | val lemma_and_constants: x:uint_t 64 ->
Lemma (logand #64 x 0 == 0 /\ logand #64 x 0xffffffffffffffff == x)
[SMTPat (logand #64 x 0); SMTPat (logand #64 x 0xffffffffffffffff)] | let lemma_and_constants x =
assert_by_tactic (logand #64 x 0 == (0 <: uint_t 64)) bv_tac;
assert_by_tactic (logand #64 x 0xffffffffffffffff == x) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 36,
"start_col": 0,
"start_line": 34
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x 0 == 0 /\ FStar.UInt.logand x 0xffffffffffffffff == x)
[SMTPat (FStar.UInt.logand x 0); SMTPat (FStar.UInt.logand x 0xffffffffffffffff)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_and_constants x =
| assert_by_tactic (logand #64 x 0 == (0 <: uint_t 64)) bv_tac;
assert_by_tactic (logand #64 x 0xffffffffffffffff == x) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_clear_lower_2 | val lemma_clear_lower_2: x:uint_t 64 ->
Lemma (logand #64 x 0xfffffffffffffffc == mul_mod #64 (udiv #64 x 4) 4)
[SMTPat (logand #64 x 0xfffffffffffffffc)] | val lemma_clear_lower_2: x:uint_t 64 ->
Lemma (logand #64 x 0xfffffffffffffffc == mul_mod #64 (udiv #64 x 4) 4)
[SMTPat (logand #64 x 0xfffffffffffffffc)] | let lemma_clear_lower_2 x =
assert_by_tactic
(logand #64 x 0xfffffffffffffffc == mul_mod #64 (udiv #64 x 4) 4)
bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 8,
"end_line": 31,
"start_col": 0,
"start_line": 28
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x 0xfffffffffffffffc == FStar.UInt.mul_mod (FStar.UInt.udiv x 4) 4)
[SMTPat (FStar.UInt.logand x 0xfffffffffffffffc)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"FStar.UInt.mul_mod",
"FStar.UInt.udiv",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_clear_lower_2 x =
| assert_by_tactic (logand #64 x 0xfffffffffffffffc == mul_mod #64 (udiv #64 x 4) 4) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod0 | val lemma_bytes_and_mod0: x: uint_t 64 ->
Lemma (logand #64 x (0x1 - 1) == mod #64 x 0x1) | val lemma_bytes_and_mod0: x: uint_t 64 ->
Lemma (logand #64 x (0x1 - 1) == mod #64 x 0x1) | let lemma_bytes_and_mod0 x =
assert_by_tactic (logand #64 x (0x1 - 1) == mod #64 x 0x1) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 194,
"start_col": 0,
"start_line": 193
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.logand x (0x1 - 1) == FStar.UInt.mod x 0x1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod0 x =
| assert_by_tactic (logand #64 x (0x1 - 1) == mod #64 x 0x1) bv_tac | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.lex_dep_relation | val lex_dep_relation
(#a: Type u#a)
(#b: (a -> Type u#b))
(wfr_a: wfr_t a)
(a_to_wfr_b: (x: a -> wfr_t (b x)))
(xy1 xy2: (x: a & b x))
: Type0 | val lex_dep_relation
(#a: Type u#a)
(#b: (a -> Type u#b))
(wfr_a: wfr_t a)
(a_to_wfr_b: (x: a -> wfr_t (b x)))
(xy1 xy2: (x: a & b x))
: Type0 | let lex_dep_relation (#a: Type u#a) (#b: a -> Type u#b) (wfr_a: wfr_t a)
(a_to_wfr_b: (x: a -> wfr_t (b x))) (xy1: (x: a & b x)) (xy2: (x: a & b x))
: Type0 =
let (| x1, y1 |), (| x2, y2 |) = xy1, xy2 in
wfr_a.relation x1 x2 \/ (x1 == x2 /\ (a_to_wfr_b x1).relation y1 y2) | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 70,
"end_line": 204,
"start_col": 0,
"start_line": 200
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
wfr_a: FStar.WellFoundedRelation.wfr_t a ->
a_to_wfr_b: (x: a -> FStar.WellFoundedRelation.wfr_t (b x)) ->
xy1: Prims.dtuple2 a (fun x -> b x) ->
xy2: Prims.dtuple2 a (fun x -> b x)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.WellFoundedRelation.wfr_t",
"Prims.dtuple2",
"Prims.l_or",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__relation",
"Prims.l_and",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | false | false | true | let lex_dep_relation
(#a: Type u#a)
(#b: (a -> Type u#b))
(wfr_a: wfr_t a)
(a_to_wfr_b: (x: a -> wfr_t (b x)))
(xy1 xy2: (x: a & b x))
: Type0 =
| let (| x1 , y1 |), (| x2 , y2 |) = xy1, xy2 in
wfr_a.relation x1 x2 \/ (x1 == x2 /\ (a_to_wfr_b x1).relation y1 y2) | false |
FStar.WellFoundedRelation.fsti | FStar.WellFoundedRelation.option_relation | val option_relation (#a: Type u#a) (wfr: wfr_t a) (opt1 opt2: option a) : Type0 | val option_relation (#a: Type u#a) (wfr: wfr_t a) (opt1 opt2: option a) : Type0 | let option_relation (#a: Type u#a) (wfr: wfr_t a) (opt1: option a) (opt2: option a) : Type0 =
Some? opt2 /\ (None? opt1 \/ wfr.relation (Some?.v opt1) (Some?.v opt2)) | {
"file_name": "ulib/FStar.WellFoundedRelation.fsti",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 74,
"end_line": 227,
"start_col": 0,
"start_line": 226
} | (*
Copyright 2022 Jay Lorch and Nikhil Swamy, Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFoundedRelation.fsti"
} | [
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
wfr: FStar.WellFoundedRelation.wfr_t a ->
opt1: FStar.Pervasives.Native.option a ->
opt2: FStar.Pervasives.Native.option a
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.WellFoundedRelation.wfr_t",
"FStar.Pervasives.Native.option",
"Prims.l_and",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.l_or",
"FStar.Pervasives.Native.uu___is_None",
"FStar.WellFoundedRelation.__proj__Mkwfr_t__item__relation",
"FStar.Pervasives.Native.__proj__Some__item__v"
... | [] | false | false | false | true | true | let option_relation (#a: Type u#a) (wfr: wfr_t a) (opt1 opt2: option a) : Type0 =
| Some? opt2 /\ (None? opt1 \/ wfr.relation (Some?.v opt1) (Some?.v opt2)) | false |
FStar.Tactics.MkProjectors.fst | FStar.Tactics.MkProjectors.mk_projs | val mk_projs (is_class:bool) (tyname:string) : Tac (list sigelt) | val mk_projs (is_class:bool) (tyname:string) : Tac (list sigelt) | let mk_projs (is_class:bool) (tyname:string) : Tac decls =
print ("!! mk_projs tactic called on: " ^ tyname);
let tyqn = explode_qn tyname in
match lookup_typ (top_env ()) tyqn with
| None ->
raise NotFound
| Some se ->
match inspect_sigelt se with
| Sg_Inductive {nm; univs; params; typ; ctors} ->... | {
"file_name": "ulib/FStar.Tactics.MkProjectors.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 29,
"end_line": 224,
"start_col": 0,
"start_line": 193
} | module FStar.Tactics.MkProjectors
(* NB: We cannot use typeclasses here, or any module that depends on
them, since they use the tactics defined here. So we must be careful
with our includes. *)
open FStar.List.Tot
open FStar.Reflection.V2
open FStar.Tactics.Effect
open FStar.Stubs.Tactics.V2.Builtins
open FStar.Stubs.... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.SyntaxHelpers.fst.checked",
"FStar.Tactics.V2.SyntaxCoercions.fst.checked",
"FStar.Tactics.V2.Derived.fst.checked",
"FStar.Tactics.Util.fst.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Tactics.N... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.NamedView",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2.Derived",
"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 | is_class: Prims.bool -> tyname: Prims.string
-> FStar.Tactics.Effect.Tac (Prims.list FStar.Stubs.Reflection.Types.sigelt) | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.bool",
"Prims.string",
"FStar.Tactics.Effect.raise",
"FStar.Stubs.Reflection.Types.decls",
"FStar.Tactics.MkProjectors.NotFound",
"FStar.Stubs.Reflection.Types.sigelt",
"FStar.Stubs.Reflection.Types.name",
"Prims.list",
"FStar.Tactics.NamedView.univ_name",
"FStar.Tactics.NamedView.binders",... | [] | false | true | false | false | false | let mk_projs (is_class: bool) (tyname: string) : Tac decls =
| print ("!! mk_projs tactic called on: " ^ tyname);
let tyqn = explode_qn tyname in
match lookup_typ (top_env ()) tyqn with
| None -> raise NotFound
| Some se ->
match inspect_sigelt se with
| Sg_Inductive { nm = nm ; univs = univs ; params = params ; typ = typ ; ctors = ctors } ->
if (length ctors <> 1) then fa... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod2 | val lemma_bytes_and_mod2: x: uint_t 64 ->
Lemma (logand #64 x (0x10000 - 1) == mod #64 x 0x10000) | val lemma_bytes_and_mod2: x: uint_t 64 ->
Lemma (logand #64 x (0x10000 - 1) == mod #64 x 0x10000) | let lemma_bytes_and_mod2 x =
assert_by_tactic (logand #64 x (0x10000 - 1) == mod #64 x 0x10000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 200,
"start_col": 0,
"start_line": 199
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.logand x (0x10000 - 1) == FStar.UInt.mod x 0x10000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod2 x =
| assert_by_tactic (logand #64 x (0x10000 - 1) == mod #64 x 0x10000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod1 | val lemma_bytes_and_mod1: x: uint_t 64 ->
Lemma (logand #64 x (0x100 - 1) == mod #64 x 0x100) | val lemma_bytes_and_mod1: x: uint_t 64 ->
Lemma (logand #64 x (0x100 - 1) == mod #64 x 0x100) | let lemma_bytes_and_mod1 x =
assert_by_tactic (logand #64 x (0x100 - 1) == mod #64 x 0x100) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 71,
"end_line": 197,
"start_col": 0,
"start_line": 196
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma (ensures FStar.UInt.logand x (0x100 - 1) == FStar.UInt.mod x 0x100) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod1 x =
| assert_by_tactic (logand #64 x (0x100 - 1) == mod #64 x 0x100) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod4 | val lemma_bytes_and_mod4: x: uint_t 64 ->
Lemma (logand #64 x (0x100000000 - 1) == mod #64 x 0x100000000) | val lemma_bytes_and_mod4: x: uint_t 64 ->
Lemma (logand #64 x (0x100000000 - 1) == mod #64 x 0x100000000) | let lemma_bytes_and_mod4 x =
assert_by_tactic (logand #64 x (0x100000000 - 1) == mod #64 x 0x100000000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 205,
"start_col": 0,
"start_line": 204
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x (0x100000000 - 1) == FStar.UInt.mod x 0x100000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod4 x =
| assert_by_tactic (logand #64 x (0x100000000 - 1) == mod #64 x 0x100000000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod5 | val lemma_bytes_and_mod5: x: uint_t 64 ->
Lemma (logand #64 x (0x10000000000 - 1) == mod #64 x 0x10000000000) | val lemma_bytes_and_mod5: x: uint_t 64 ->
Lemma (logand #64 x (0x10000000000 - 1) == mod #64 x 0x10000000000) | let lemma_bytes_and_mod5 x =
assert_by_tactic (logand #64 x (0x10000000000 - 1) == mod #64 x 0x10000000000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 87,
"end_line": 208,
"start_col": 0,
"start_line": 207
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x (0x10000000000 - 1) == FStar.UInt.mod x 0x10000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod5 x =
| assert_by_tactic (logand #64 x (0x10000000000 - 1) == mod #64 x 0x10000000000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod6 | val lemma_bytes_and_mod6: x: uint_t 64 ->
Lemma (logand #64 x (0x1000000000000 - 1) == mod #64 x 0x1000000000000) | val lemma_bytes_and_mod6: x: uint_t 64 ->
Lemma (logand #64 x (0x1000000000000 - 1) == mod #64 x 0x1000000000000) | let lemma_bytes_and_mod6 x =
assert_by_tactic (logand #64 x (0x1000000000000 - 1) == mod #64 x 0x1000000000000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 91,
"end_line": 211,
"start_col": 0,
"start_line": 210
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x (0x1000000000000 - 1) == FStar.UInt.mod x 0x1000000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod6 x =
| assert_by_tactic (logand #64 x (0x1000000000000 - 1) == mod #64 x 0x1000000000000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod3 | val lemma_bytes_and_mod3: x: uint_t 64 ->
Lemma (logand #64 x (0x1000000 - 1) == mod #64 x 0x1000000) | val lemma_bytes_and_mod3: x: uint_t 64 ->
Lemma (logand #64 x (0x1000000 - 1) == mod #64 x 0x1000000) | let lemma_bytes_and_mod3 x =
assert_by_tactic (logand #64 x (0x1000000 - 1) == mod #64 x 0x1000000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 202,
"start_col": 0,
"start_line": 201
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x (0x1000000 - 1) == FStar.UInt.mod x 0x1000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod3 x =
| assert_by_tactic (logand #64 x (0x1000000 - 1) == mod #64 x 0x1000000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.mul_bvshl | val mul_bvshl (u: uint_t 64)
: Lemma
(0x10000000000000000 * u < pow2 128 /\
(int2bv #128 (0x10000000000000000 * u) == bvshl (bv_uext #64 #64 (int2bv u)) 64)) | val mul_bvshl (u: uint_t 64)
: Lemma
(0x10000000000000000 * u < pow2 128 /\
(int2bv #128 (0x10000000000000000 * u) == bvshl (bv_uext #64 #64 (int2bv u)) 64)) | let mul_bvshl (u:uint_t 64) :
Lemma (0x10000000000000000 * u < pow2 128 /\
(int2bv #128 (0x10000000000000000 * u) ==
bvshl (bv_uext #64 #64 (int2bv u)) 64)) =
assert_norm ( 0x10000000000000000 * pow2 63 < pow2 128);
modulo_lemma (0x10000000000000000 * u) (pow2 128);
assert_by_tactic
(int2... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 101,
"start_col": 0,
"start_line": 92
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"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 | u99: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures
0x10000000000000000 * u99 < Prims.pow2 128 /\
FStar.BV.int2bv (0x10000000000000000 * u99) ==
FStar.BV.bvshl (FStar.BV.bv_uext (FStar.BV.int2bv u99)) 64) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BV.bv_t",
"FStar.BV.int2bv",
"FStar.UInt.mul_mod",
"Vale.Poly1305.Bitvectors.uint_ext",
"FStar.BV.bvmul",
"Prims.unit",
"FStar.Tactics.V1.Derived.trefl",
"FStar.Tactics.BV.arith_to_bv_tac",
"FStar.Tactics.V1.Deri... | [] | false | false | true | false | false | let mul_bvshl (u: uint_t 64)
: Lemma
(0x10000000000000000 * u < pow2 128 /\
(int2bv #128 (0x10000000000000000 * u) == bvshl (bv_uext #64 #64 (int2bv u)) 64)) =
| assert_norm (0x10000000000000000 * pow2 63 < pow2 128);
modulo_lemma (0x10000000000000000 * u) (pow2 128);
assert_by_tactic (int2bv #128 (mul_mod #128 0x10000000000000000 (uint_ext #64 #128 u)) ==
bvmul #128 (int2bv #128 0x10000000000000000) (uint_ext #64 #128 u))
(fun () ->
mapply (`trans);
arith_to_... | false |
CQueue.fst | CQueue.elim_vbind | val elim_vbind (#opened: _) (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop))
: SteelGhost (Ghost.erased (t_of a))
opened
(vbind a t b)
(fun res -> a `star` (b (Ghost.reveal res)))
(fun h -> True)
(fun h res h' ->
h' a == Ghost.reveal res /\ t == t_of (b (Ghost.reveal res)) /\... | val elim_vbind (#opened: _) (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop))
: SteelGhost (Ghost.erased (t_of a))
opened
(vbind a t b)
(fun res -> a `star` (b (Ghost.reveal res)))
(fun h -> True)
(fun h res h' ->
h' a == Ghost.reveal res /\ t == t_of (b (Ghost.reveal res)) /\... | let elim_vbind
(#opened: _)
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
: SteelGhost (Ghost.erased (t_of a)) opened
(vbind a t b)
(fun res -> a `star` b (Ghost.reveal res))
(fun h -> True)
(fun h res h' ->
h' a == Ghost.reveal res /\
t == t_of (b (Ghost.reveal res)) /\
h' ... | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 277,
"start_col": 0,
"start_line": 249
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source... | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
a: Steel.Effect.Common.vprop ->
t: Type0 ->
b: (_: Steel.Effect.Common.t_of a -> Steel.Effect.Common.vprop)
-> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased (Steel.Effect.Common.t_of a)) | Steel.Effect.Atomic.SteelGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"FStar.Ghost.erased",
"Prims.unit",
"CQueue.elim_vpure",
"Prims.eq2",
"FStar.Ghost.reveal",
"Steel.Effect.Atomic.change_equal_slprop",
"CQueue.vbind0_payload",
"Steel.Effect.Common.star",
"CQueue.vpure",
"Steel.E... | [] | false | true | false | false | false | let elim_vbind (#opened: _) (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop))
: SteelGhost (Ghost.erased (t_of a))
opened
(vbind a t b)
(fun res -> a `star` (b (Ghost.reveal res)))
(fun h -> True)
(fun h res h' ->
h' a == Ghost.reveal res /\ t == t_of (b (Ghost.reveal res)) /\... | change_slprop_rel (vbind a t b) (vbind0 a t b) (fun x y -> x == y) (fun _ -> ());
elim_vrewrite (a `vdep` (vbind0_payload a t b)) (vbind0_rewrite a t b);
let res = elim_vdep a (vbind0_payload a t b) in
change_equal_slprop (vbind0_payload a t b (Ghost.reveal res))
((vpure (t == t_of (b (Ghost.reveal res)))) `star` (b ... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants0 | val lemma_bytes_shift_constants0: unit -> Lemma
(shift_left #64 0 3 == 0 /\
shift_left #64 1 (shift_left #64 0 3) == 0x1) | val lemma_bytes_shift_constants0: unit -> Lemma
(shift_left #64 0 3 == 0 /\
shift_left #64 1 (shift_left #64 0 3) == 0x1) | let lemma_bytes_shift_constants0 x =
assert_by_tactic (shift_left #64 0 3 == (0 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 0 == (0x1 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 170,
"start_col": 0,
"start_line": 168
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 0 3 == 0 /\ FStar.UInt.shift_left 1 (FStar.UInt.shift_left 0 3) == 0x1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants0 x =
| assert_by_tactic (shift_left #64 0 3 == (0 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 0 == (0x1 <: uint_t 64)) bv_tac | false |
Steel.Effect.Common.fst | Steel.Effect.Common.can_be_split | val can_be_split (p q:pre_t) : Type0 | val can_be_split (p q:pre_t) : Type0 | let can_be_split (p q:vprop) : prop = Mem.slimp (hp_of p) (hp_of q) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 67,
"end_line": 25,
"start_col": 0,
"start_line": 25
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.pre_t -> q: Steel.Effect.Common.pre_t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.slimp",
"Steel.Effect.Common.hp_of",
"Prims.prop"
] | [] | false | false | false | true | true | let can_be_split (p q: vprop) : prop =
| Mem.slimp (hp_of p) (hp_of q) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.int2bv_uext_64_128 | val int2bv_uext_64_128 (x1: nat)
: Lemma (requires (FStar.UInt.size x1 64))
(ensures (bv_uext #64 #64 (int2bv #64 x1) == int2bv #128 x1)) | val int2bv_uext_64_128 (x1: nat)
: Lemma (requires (FStar.UInt.size x1 64))
(ensures (bv_uext #64 #64 (int2bv #64 x1) == int2bv #128 x1)) | let int2bv_uext_64_128 (x1 : nat) :
Lemma (requires (FStar.UInt.size x1 64))
(ensures (bv_uext #64 #64 (int2bv #64 x1) == int2bv #128 x1)) =
assert (64 <= 128);
pow2_le_compat 128 64;
assert (x1 < pow2 128);
modulo_lemma x1 (pow2 128); // x1 % pow2 128 = x1
assert (FStar.UInt.size x1 128);
... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 127,
"start_col": 0,
"start_line": 115
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"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 | x1: Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.UInt.size x1 64)
(ensures FStar.BV.bv_uext (FStar.BV.int2bv x1) == FStar.BV.int2bv x1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.BV.bv_t",
"FStar.BV.bv_uext",
"FStar.BV.int2bv",
"Prims.unit",
"FStar.Tactics.V1.Derived.smt",
"FStar.Stubs.Tactics.V1.Builtins.dump",
"FStar.Stubs.Tactics.V1.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
... | [] | false | false | true | false | false | let int2bv_uext_64_128 (x1: nat)
: Lemma (requires (FStar.UInt.size x1 64))
(ensures (bv_uext #64 #64 (int2bv #64 x1) == int2bv #128 x1)) =
| assert (64 <= 128);
pow2_le_compat 128 64;
assert (x1 < pow2 128);
modulo_lemma x1 (pow2 128);
assert (FStar.UInt.size x1 128);
assert_by_tactic (bv_uext #64 #64 (int2bv #64 x1) == int2bv #128 x1)
(fun () ->
dump "..";
norm [delta_only [`%uint_ext; `%FStar.UInt.to_uint_t]];
dump "After norm";
... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_lowerUpper128_andu | val lemma_lowerUpper128_andu : x:uint_t 128 -> x0:uint_t 64 -> x1:uint_t 64 -> y:uint_t 128 ->
y0:uint_t 64 -> y1:uint_t 64 -> z:uint_t 128 -> z0:uint_t 64 ->
z1:uint_t 64 -> Lemma
(requires z0 == logand #64 x0 y0 /\
z1 == logand #64 x1 y1 /\
... | val lemma_lowerUpper128_andu : x:uint_t 128 -> x0:uint_t 64 -> x1:uint_t 64 -> y:uint_t 128 ->
y0:uint_t 64 -> y1:uint_t 64 -> z:uint_t 128 -> z0:uint_t 64 ->
z1:uint_t 64 -> Lemma
(requires z0 == logand #64 x0 y0 /\
z1 == logand #64 x1 y1 /\
... | let lemma_lowerUpper128_andu
(x:uint_t 128) (x0:uint_t 64) (x1:uint_t 64) (y:uint_t 128)
(y0:uint_t 64) (y1:uint_t 64) (z:uint_t 128) (z0:uint_t 64) (z1:uint_t 64) :
Lemma
(requires
z0 == logand #64 x0 y0 /\
z1 == logand #64 x1 y1 /\
x == lowerUpper128u x0 x1 /\
y == lowerUpper128u... | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 165,
"start_col": 0,
"start_line": 140
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: FStar.UInt.uint_t 128 ->
x0: FStar.UInt.uint_t 64 ->
x1: FStar.UInt.uint_t 64 ->
y: FStar.UInt.uint_t 128 ->
y0: FStar.UInt.uint_t 64 ->
y1: FStar.UInt.uint_t 64 ->
z: FStar.UInt.uint_t 128 ->
z0: FStar.UInt.uint_t 64 ->
z1: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Vale.Poly1305.Bitvectors.lowerUpper128m",
"Vale.Poly1305.Bitvectors.lowerUpper128u",
"Vale.Math.Bits.lemma_i2b_equal",
"FStar.UInt.logand",
"FStar.BV.bv_t",
"Vale.Poly1305.Bitvectors.lowerUpper128b",
"Vale.Math.Bits... | [] | true | false | true | false | false | let lemma_lowerUpper128_andu
(x: uint_t 128)
(x0 x1: uint_t 64)
(y: uint_t 128)
(y0 y1: uint_t 64)
(z: uint_t 128)
(z0 z1: uint_t 64)
: Lemma
(requires
z0 == logand #64 x0 y0 /\ z1 == logand #64 x1 y1 /\ x == lowerUpper128u x0 x1 /\
y == lowerUpper128u y0 y1... | let bx0 = b_i2b x0 in
let bx1 = b_i2b x1 in
let by0 = b_i2b y0 in
let by1 = b_i2b y1 in
assert_norm (lowerUpper128b (b_and bx0 by0) (b_and bx1 by1) ==
b_and (lowerUpper128b bx0 bx1) (lowerUpper128b by0 by1));
lemma_i2b_equal (lowerUpper128m (logand x0 y0) (logand x1 y1))
(logand (lowerUpper128m x0 x1) (lowerUpper... | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants4 | val lemma_bytes_shift_constants4: unit -> Lemma
(shift_left #64 4 3 == 32 /\
shift_left #64 1 (shift_left #64 4 3) == 0x100000000) | val lemma_bytes_shift_constants4: unit -> Lemma
(shift_left #64 4 3 == 32 /\
shift_left #64 1 (shift_left #64 4 3) == 0x100000000) | let lemma_bytes_shift_constants4 x =
assert_by_tactic (shift_left #64 4 3 == (32 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 32 == (0x100000000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 182,
"start_col": 0,
"start_line": 180
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 4 3 == 32 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 4 3) == 0x100000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants4 x =
| assert_by_tactic (shift_left #64 4 3 == (32 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 32 == (0x100000000 <: uint_t 64)) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants6 | val lemma_bytes_shift_constants6: unit -> Lemma
(shift_left #64 6 3 == 48 /\
shift_left #64 1 (shift_left #64 6 3) == 0x1000000000000) | val lemma_bytes_shift_constants6: unit -> Lemma
(shift_left #64 6 3 == 48 /\
shift_left #64 1 (shift_left #64 6 3) == 0x1000000000000) | let lemma_bytes_shift_constants6 x =
assert_by_tactic (shift_left #64 6 3 == (48 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 48 == (0x1000000000000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 81,
"end_line": 188,
"start_col": 0,
"start_line": 186
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 6 3 == 48 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 6 3) == 0x1000000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants6 x =
| assert_by_tactic (shift_left #64 6 3 == (48 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 48 == (0x1000000000000 <: uint_t 64)) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants2 | val lemma_bytes_shift_constants2: unit -> Lemma
(shift_left #64 2 3 == 16 /\
shift_left #64 1 (shift_left #64 2 3) == 0x10000) | val lemma_bytes_shift_constants2: unit -> Lemma
(shift_left #64 2 3 == 16 /\
shift_left #64 1 (shift_left #64 2 3) == 0x10000) | let lemma_bytes_shift_constants2 x =
assert_by_tactic (shift_left #64 2 3 == (16 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 16 == (0x10000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 73,
"end_line": 176,
"start_col": 0,
"start_line": 174
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 2 3 == 16 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 2 3) == 0x10000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants2 x =
| assert_by_tactic (shift_left #64 2 3 == (16 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 16 == (0x10000 <: uint_t 64)) bv_tac | false |
Steel.Effect.Common.fst | Steel.Effect.Common.equiv | val equiv (p q:vprop) : prop | val equiv (p q:vprop) : prop | let equiv (p q:vprop) : prop = Mem.equiv (hp_of p) (hp_of q) /\ True | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 68,
"end_line": 44,
"start_col": 0,
"start_line": 44
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Prims.l_and",
"Steel.Memory.equiv",
"Steel.Effect.Common.hp_of",
"Prims.l_True",
"Prims.prop"
] | [] | false | false | false | true | true | let equiv (p q: vprop) : prop =
| Mem.equiv (hp_of p) (hp_of q) /\ True | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants7 | val lemma_bytes_shift_constants7: unit -> Lemma
(shift_left #64 7 3 == 56 /\
shift_left #64 1 (shift_left #64 7 3) == 0x100000000000000) | val lemma_bytes_shift_constants7: unit -> Lemma
(shift_left #64 7 3 == 56 /\
shift_left #64 1 (shift_left #64 7 3) == 0x100000000000000) | let lemma_bytes_shift_constants7 x =
assert_by_tactic (shift_left #64 7 3 == (56 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 56 == (0x100000000000000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 83,
"end_line": 191,
"start_col": 0,
"start_line": 189
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 7 3 == 56 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 7 3) == 0x100000000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants7 x =
| assert_by_tactic (shift_left #64 7 3 == (56 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 56 == (0x100000000000000 <: uint_t 64)) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_and_mod7 | val lemma_bytes_and_mod7: x: uint_t 64 ->
Lemma (logand #64 x (0x100000000000000 - 1) == mod #64 x 0x100000000000000) | val lemma_bytes_and_mod7: x: uint_t 64 ->
Lemma (logand #64 x (0x100000000000000 - 1) == mod #64 x 0x100000000000000) | let lemma_bytes_and_mod7 x =
assert_by_tactic (logand #64 x (0x100000000000000 - 1) == mod #64 x 0x100000000000000) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 214,
"start_col": 0,
"start_line": 213
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures FStar.UInt.logand x (0x100000000000000 - 1) == FStar.UInt.mod x 0x100000000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"Prims.op_Subtraction",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_bytes_and_mod7 x =
| assert_by_tactic (logand #64 x (0x100000000000000 - 1) == mod #64 x 0x100000000000000) bv_tac | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_and_mod_n | val lemma_and_mod_n: x:uint_t 64 -> Lemma (logand #64 x 3 == mod #64 x 4 /\
logand #64 x 15 == mod #64 x 16)
[SMTPat (logand #64 x 3);
SMTPat (logand #64 x 15)] | val lemma_and_mod_n: x:uint_t 64 -> Lemma (logand #64 x 3 == mod #64 x 4 /\
logand #64 x 15 == mod #64 x 16)
[SMTPat (logand #64 x 3);
SMTPat (logand #64 x 15)] | let lemma_and_mod_n x =
assert_by_tactic (logand #64 x 3 == mod #64 x 4) (bv_tac);
assert_by_tactic (logand #64 x 15 == mod #64 x 16) (bv_tac) | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 26,
"start_col": 0,
"start_line": 24
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: FStar.UInt.uint_t 64
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.logand x 3 == FStar.UInt.mod x 4 /\ FStar.UInt.logand x 15 == FStar.UInt.mod x 16
) [SMTPat (FStar.UInt.logand x 3); SMTPat (FStar.UInt.logand x 15)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.UInt.uint_t",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.logand",
"FStar.UInt.mod",
"FStar.Tactics.BV.bv_tac",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_and_mod_n x =
| assert_by_tactic (logand #64 x 3 == mod #64 x 4) (bv_tac);
assert_by_tactic (logand #64 x 15 == mod #64 x 16) (bv_tac) | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants3 | val lemma_bytes_shift_constants3: unit -> Lemma
(shift_left #64 3 3 == 24 /\
shift_left #64 1 (shift_left #64 3 3) == 0x1000000) | val lemma_bytes_shift_constants3: unit -> Lemma
(shift_left #64 3 3 == 24 /\
shift_left #64 1 (shift_left #64 3 3) == 0x1000000) | let lemma_bytes_shift_constants3 x =
assert_by_tactic (shift_left #64 3 3 == (24 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 24 == (0x1000000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 179,
"start_col": 0,
"start_line": 177
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 3 3 == 24 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 3 3) == 0x1000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants3 x =
| assert_by_tactic (shift_left #64 3 3 == (24 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 24 == (0x1000000 <: uint_t 64)) bv_tac | false |
Steel.Effect.Common.fst | Steel.Effect.Common.emp | val emp : vprop | val emp : vprop | let emp = VUnit emp' | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 20,
"end_line": 61,
"start_col": 0,
"start_line": 61
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.emp'"
] | [] | false | false | false | true | false | let emp =
| VUnit emp' | false |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants5 | val lemma_bytes_shift_constants5: unit -> Lemma
(shift_left #64 5 3 == 40 /\
shift_left #64 1 (shift_left #64 5 3) == 0x10000000000) | val lemma_bytes_shift_constants5: unit -> Lemma
(shift_left #64 5 3 == 40 /\
shift_left #64 1 (shift_left #64 5 3) == 0x10000000000) | let lemma_bytes_shift_constants5 x =
assert_by_tactic (shift_left #64 5 3 == (40 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 40 == (0x10000000000 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 185,
"start_col": 0,
"start_line": 183
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 5 3 == 40 /\
FStar.UInt.shift_left 1 (FStar.UInt.shift_left 5 3) == 0x10000000000) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants5 x =
| assert_by_tactic (shift_left #64 5 3 == (40 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 40 == (0x10000000000 <: uint_t 64)) bv_tac | false |
Steel.Effect.Common.fst | Steel.Effect.Common.h_exists | val h_exists : f: (_: _ -> Steel.Effect.Common.vprop) -> Steel.Effect.Common.vprop | let h_exists #a f = VUnit ({hp = Mem.h_exists (fun x -> hp_of (f x)); t = unit; sel = fun _ -> ()}) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 99,
"end_line": 23,
"start_col": 0,
"start_line": 23
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"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: (_: _ -> Steel.Effect.Common.vprop) -> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.Mkvprop'",
"Steel.Memory.h_exists",
"Steel.Effect.Common.hp_of",
"Steel.Memory.slprop",
"Prims.unit",
"Steel.Memory.hmem"
] | [] | false | false | false | true | false | let h_exists #a f =
| VUnit ({ hp = Mem.h_exists (fun x -> hp_of (f x)); t = unit; sel = fun _ -> () }) | false | |
Vale.Poly1305.Bitvectors.fst | Vale.Poly1305.Bitvectors.lemma_bytes_shift_constants1 | val lemma_bytes_shift_constants1: unit -> Lemma
(shift_left #64 1 3 == 8 /\
shift_left #64 1 (shift_left #64 1 3) == 0x100) | val lemma_bytes_shift_constants1: unit -> Lemma
(shift_left #64 1 3 == 8 /\
shift_left #64 1 (shift_left #64 1 3) == 0x100) | let lemma_bytes_shift_constants1 x =
assert_by_tactic (shift_left #64 1 3 == (8 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 8 == (0x100 <: uint_t 64)) bv_tac | {
"file_name": "vale/code/crypto/poly1305/x64/Vale.Poly1305.Bitvectors.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 173,
"start_col": 0,
"start_line": 171
} | module Vale.Poly1305.Bitvectors
open FStar.BV
open FStar.Tactics
open FStar.Tactics.Derived
open FStar.Tactics.BV
open FStar.Mul
open FStar.UInt
open FStar.Math.Lemmas
open Vale.Lib.Tactics
open Vale.Lib.Bv_s
open Vale.Math.Bits
// tweak options?
#reset-options "--smtencoding.elim_box true"
//NOTE: Using the split ta... | {
"checked_file": "/",
"dependencies": [
"Vale.Math.Bits.fsti.checked",
"Vale.Lib.Tactics.fst.checked",
"Vale.Lib.Bv_s.fst.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.Derived.fst.checked",
"FStar.Tactics.BV.fst.checked",
"FStar.Tactics.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Vale.Math.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Bv_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Lib.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
FStar.UInt.shift_left 1 3 == 8 /\ FStar.UInt.shift_left 1 (FStar.UInt.shift_left 1 3) == 0x100
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.UInt.uint_t",
"FStar.UInt.shift_left",
"FStar.Tactics.BV.bv_tac"
] | [] | true | false | true | false | false | let lemma_bytes_shift_constants1 x =
| assert_by_tactic (shift_left #64 1 3 == (8 <: uint_t 64)) bv_tac;
assert_by_tactic (shift_left #64 1 8 == (0x100 <: uint_t 64)) bv_tac | false |
Steel.Effect.Common.fst | Steel.Effect.Common.can_be_split_congr_l | val can_be_split_congr_l
(p q r: vprop)
: Lemma
(requires (p `can_be_split` q))
(ensures ((p `star` r) `can_be_split` (q `star` r))) | val can_be_split_congr_l
(p q r: vprop)
: Lemma
(requires (p `can_be_split` q))
(ensures ((p `star` r) `can_be_split` (q `star` r))) | let can_be_split_congr_l p q r =
Classical.forall_intro (interp_star (hp_of p) (hp_of r));
Classical.forall_intro (interp_star (hp_of q) (hp_of r)) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 58,
"end_line": 38,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop -> r: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma (requires Steel.Effect.Common.can_be_split p q)
(ensures
Steel.Effect.Common.can_be_split (Steel.Effect.Common.star p r)
(Steel.Effect.Common.star q r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"FStar.Classical.forall_intro",
"Steel.Memory.mem",
"Prims.l_iff",
"Steel.Memory.interp",
"Steel.Memory.star",
"Steel.Effect.Common.hp_of",
"Prims.l_Exists",
"Prims.l_and",
"Steel.Memory.disjoint",
"Prims.eq2",
"Steel.Memory.join",
"Steel.Memory.interp_star",
"... | [] | false | false | true | false | false | let can_be_split_congr_l p q r =
| Classical.forall_intro (interp_star (hp_of p) (hp_of r));
Classical.forall_intro (interp_star (hp_of q) (hp_of r)) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.can_be_split_congr_r | val can_be_split_congr_r
(p q r: vprop)
: Lemma
(requires (p `can_be_split` q))
(ensures ((r `star` p) `can_be_split` (r `star` q))) | val can_be_split_congr_r
(p q r: vprop)
: Lemma
(requires (p `can_be_split` q))
(ensures ((r `star` p) `can_be_split` (r `star` q))) | let can_be_split_congr_r p q r =
Classical.forall_intro (interp_star (hp_of r) (hp_of p));
Classical.forall_intro (interp_star (hp_of r) (hp_of q)) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 58,
"end_line": 42,
"start_col": 0,
"start_line": 40
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: Steel.Effect.Common.vprop -> q: Steel.Effect.Common.vprop -> r: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma (requires Steel.Effect.Common.can_be_split p q)
(ensures
Steel.Effect.Common.can_be_split (Steel.Effect.Common.star r p)
(Steel.Effect.Common.star r q)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"FStar.Classical.forall_intro",
"Steel.Memory.mem",
"Prims.l_iff",
"Steel.Memory.interp",
"Steel.Memory.star",
"Steel.Effect.Common.hp_of",
"Prims.l_Exists",
"Prims.l_and",
"Steel.Memory.disjoint",
"Prims.eq2",
"Steel.Memory.join",
"Steel.Memory.interp_star",
"... | [] | false | false | true | false | false | let can_be_split_congr_r p q r =
| Classical.forall_intro (interp_star (hp_of r) (hp_of p));
Classical.forall_intro (interp_star (hp_of r) (hp_of q)) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.vdep_hp | val vdep_hp (v: vprop) (p: ( (t_of v) -> Tot vprop)) : Tot (slprop u#1) | val vdep_hp (v: vprop) (p: ( (t_of v) -> Tot vprop)) : Tot (slprop u#1) | let vdep_hp
v p
=
sdep (hp_of v) (vdep_hp_payload v p) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 38,
"end_line": 151,
"start_col": 0,
"start_line": 148
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommMonoidSimple.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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 | v: Steel.Effect.Common.vprop -> p: (_: Steel.Effect.Common.t_of v -> Steel.Effect.Common.vprop)
-> Steel.Memory.slprop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Memory.sdep",
"Steel.Effect.Common.hp_of",
"Steel.Effect.Common.vdep_hp_payload",
"Steel.Memory.slprop"
] | [] | false | false | false | false | false | let vdep_hp v p =
| sdep (hp_of v) (vdep_hp_payload v p) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.emp' | val emp':vprop' | val emp':vprop' | let emp':vprop' =
{ hp = emp;
t = unit;
sel = fun _ -> ()} | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 60,
"start_col": 0,
"start_line": 57
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Steel.Effect.Common.vprop' | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.Mkvprop'",
"Steel.Memory.emp",
"Prims.unit",
"Steel.Memory.hmem"
] | [] | false | false | false | true | false | let emp':vprop' =
| { hp = emp; t = unit; sel = fun _ -> () } | false |
Steel.Effect.Common.fst | Steel.Effect.Common.reveal_mk_rmem | val reveal_mk_rmem (r:vprop) (h:hmem r) (r0:vprop{r `can_be_split` r0})
: Lemma (ensures reveal_can_be_split(); (mk_rmem r h) r0 == sel_of r0 h) | val reveal_mk_rmem (r:vprop) (h:hmem r) (r0:vprop{r `can_be_split` r0})
: Lemma (ensures reveal_can_be_split(); (mk_rmem r h) r0 == sel_of r0 h) | let reveal_mk_rmem (r:vprop) (h:hmem r) (r0:vprop{r `can_be_split` r0})
: Lemma ((mk_rmem r h) r0 == sel_of r0 h)
= FExt.feq_on_domain_g (unrestricted_mk_rmem r h) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 51,
"end_line": 55,
"start_col": 0,
"start_line": 53
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"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: Steel.Effect.Common.vprop ->
h: Steel.Effect.Common.hmem r ->
r0: Steel.Effect.Common.vprop{Steel.Effect.Common.can_be_split r r0}
-> FStar.Pervasives.Lemma
(ensures
(Steel.Effect.Common.reveal_can_be_split ();
Steel.Effect.Common.mk_rmem r h r0 == Steel.Effect.Common.sel_of r0 h)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.hmem",
"Steel.Effect.Common.can_be_split",
"FStar.FunctionalExtensionality.feq_on_domain_g",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.unrestricted_mk_rmem",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Steel.Effect.Common.n... | [] | true | false | true | false | false | let reveal_mk_rmem (r: vprop) (h: hmem r) (r0: vprop{r `can_be_split` r0})
: Lemma ((mk_rmem r h) r0 == sel_of r0 h) =
| FExt.feq_on_domain_g (unrestricted_mk_rmem r h) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.lemma_valid_focus_rmem | val lemma_valid_focus_rmem (#r:vprop) (h:rmem r) (r0:vprop{r `can_be_split` r0})
: Lemma (valid_rmem (focus_rmem' h r0)) | val lemma_valid_focus_rmem (#r:vprop) (h:rmem r) (r0:vprop{r `can_be_split` r0})
: Lemma (valid_rmem (focus_rmem' h r0)) | let lemma_valid_focus_rmem #r h r0 =
Classical.forall_intro (Classical.move_requires (can_be_split_trans r r0)) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 76,
"end_line": 66,
"start_col": 0,
"start_line": 65
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"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: Steel.Effect.Common.rmem r ->
r0: Steel.Effect.Common.vprop{Steel.Effect.Common.can_be_split r r0}
-> FStar.Pervasives.Lemma
(ensures Steel.Effect.Common.valid_rmem (Steel.Effect.Common.focus_rmem' h r0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.can_be_split",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"Prims.l_and",
"FStar.Classical.move_requires",
"Steel.Effect.Common.can_be_split_trans",
"Prims.unit"
] | [] | false | false | true | false | false | let lemma_valid_focus_rmem #r h r0 =
| Classical.forall_intro (Classical.move_requires (can_be_split_trans r r0)) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.valid_rmem | val valid_rmem (#frame:vprop) (h:rmem' frame) : prop | val valid_rmem (#frame:vprop) (h:rmem' frame) : prop | let valid_rmem (#frame:vprop) (h:rmem' frame) : prop =
forall (p p1 p2:vprop). can_be_split frame p /\ p == VStar p1 p2 ==>
(h p1, h p2) == h (VStar p1 p2) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 49,
"start_col": 0,
"start_line": 47
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbre... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"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: Steel.Effect.Common.rmem' frame -> Prims.prop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem'",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Steel.Effect.Common.can_be_split",
"Prims.eq2",
"Steel.Effect.Common.VStar",
"FStar.Pervasives.Native.tuple2",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.__proj__Mkvprop'__item__t",... | [] | false | false | false | false | true | let valid_rmem (#frame: vprop) (h: rmem' frame) : prop =
| forall (p: vprop) (p1: vprop) (p2: vprop).
can_be_split frame p /\ p == VStar p1 p2 ==> (h p1, h p2) == h (VStar p1 p2) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.star_associative | val star_associative (p1 p2 p3:vprop)
: Lemma (((p1 `star` p2) `star` p3)
`equiv`
(p1 `star` (p2 `star` p3))) | val star_associative (p1 p2 p3:vprop)
: Lemma (((p1 `star` p2) `star` p3)
`equiv`
(p1 `star` (p2 `star` p3))) | let star_associative p1 p2 p3 = Mem.star_associative (hp_of p1) (hp_of p2) (hp_of p3) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 85,
"end_line": 111,
"start_col": 0,
"start_line": 111
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommMonoidSimple.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop -> p3: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma
(ensures
Steel.Effect.Common.equiv (Steel.Effect.Common.star (Steel.Effect.Common.star p1 p2) p3)
(Steel.Effect.Common.star p1 (Steel.Effect.Common.star p2 p3))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.star_associative",
"Steel.Effect.Common.hp_of",
"Prims.unit"
] | [] | true | false | true | false | false | let star_associative p1 p2 p3 =
| Mem.star_associative (hp_of p1) (hp_of p2) (hp_of p3) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.lemma_frame_emp | val lemma_frame_emp (h0:rmem emp) (h1:rmem emp) (p:Type0)
: Lemma (requires True == p)
(ensures frame_equalities' emp h0 h1 == p) | val lemma_frame_emp (h0:rmem emp) (h1:rmem emp) (p:Type0)
: Lemma (requires True == p)
(ensures frame_equalities' emp h0 h1 == p) | let lemma_frame_emp h0 h1 p =
FStar.PropositionalExtensionality.apply True (h0 (VUnit emp') == h1 (VUnit emp')) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 83,
"end_line": 92,
"start_col": 0,
"start_line": 91
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"a... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
h0: Steel.Effect.Common.rmem Steel.Effect.Common.emp ->
h1: Steel.Effect.Common.rmem Steel.Effect.Common.emp ->
p: Type0
-> FStar.Pervasives.Lemma (requires Prims.l_True == p)
(ensures Steel.Effect.Common.frame_equalities' Steel.Effect.Common.emp h0 h1 == p) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.emp",
"FStar.PropositionalExtensionality.apply",
"Prims.l_True",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.VUnit",
"Steel.Effect.Common.emp'",
"Prims.unit"
] | [] | true | false | true | false | false | let lemma_frame_emp h0 h1 p =
| FStar.PropositionalExtensionality.apply True (h0 (VUnit emp') == h1 (VUnit emp')) | false |
Steel.Effect.Common.fst | Steel.Effect.Common.lemma_frame_refl' | val lemma_frame_refl' (frame: vprop) (h0 h1: rmem frame)
: Lemma ((h0 frame == h1 frame) <==> frame_equalities' frame h0 h1) | val lemma_frame_refl' (frame: vprop) (h0 h1: rmem frame)
: Lemma ((h0 frame == h1 frame) <==> frame_equalities' frame h0 h1) | let rec lemma_frame_refl' (frame:vprop) (h0:rmem frame) (h1:rmem frame)
: Lemma ((h0 frame == h1 frame) <==> frame_equalities' frame h0 h1)
= match frame with
| VUnit _ -> ()
| VStar p1 p2 ->
can_be_split_star_l p1 p2;
can_be_split_star_r p1 p2;
let h01 : rmem p1 = focus_rmem h0 p1 in
... | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 83,
"start_col": 0,
"start_line": 68
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"a... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
frame: Steel.Effect.Common.vprop ->
h0: Steel.Effect.Common.rmem frame ->
h1: Steel.Effect.Common.rmem frame
-> FStar.Pervasives.Lemma
(ensures h0 frame == h1 frame <==> Steel.Effect.Common.frame_equalities' frame h0 h1) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Steel.Effect.Common.vprop'",
"Steel.Effect.Common.lemma_frame_refl'",
"Prims.unit",
"Steel.Effect.Common.rmem'",
"Steel.Effect.Common.valid_rmem",
"Steel.Effect.Common.focus_rmem",
"Steel.Effect.Common.can_be_split_star_r",
"Steel.Effect.Co... | [
"recursion"
] | false | false | true | false | false | let rec lemma_frame_refl' (frame: vprop) (h0 h1: rmem frame)
: Lemma ((h0 frame == h1 frame) <==> frame_equalities' frame h0 h1) =
| match frame with
| VUnit _ -> ()
| VStar p1 p2 ->
can_be_split_star_l p1 p2;
can_be_split_star_r p1 p2;
let h01:rmem p1 = focus_rmem h0 p1 in
let h11:rmem p1 = focus_rmem h1 p1 in
let h02 = focus_rmem h0 p2 in
let h12 = focus_rmem h1 p2 in
lemma_frame_refl' p1 h01 h11;
lemma_frame_refl' p2 h02 h12 | false |
Steel.Effect.Common.fst | Steel.Effect.Common.lemma_frame_equalities | val lemma_frame_equalities (frame:vprop) (h0:rmem frame) (h1:rmem frame) (p:Type0)
: Lemma
(requires (h0 frame == h1 frame) == p)
(ensures frame_equalities' frame h0 h1 == p) | val lemma_frame_equalities (frame:vprop) (h0:rmem frame) (h1:rmem frame) (p:Type0)
: Lemma
(requires (h0 frame == h1 frame) == p)
(ensures frame_equalities' frame h0 h1 == p) | let lemma_frame_equalities frame h0 h1 p =
let p1 : prop = h0 frame == h1 frame in
let p2 : prop = frame_equalities' frame h0 h1 in
lemma_frame_refl' frame h0 h1;
FStar.PropositionalExtensionality.apply p1 p2 | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 47,
"end_line": 89,
"start_col": 0,
"start_line": 85
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.FunctionalExtensionality",
"short_module": "FExt"
},
{
"abbrev": false,
"full_module": "Steel.Semantics.Instantiate",
"short_module": null
},
{
"a... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
frame: Steel.Effect.Common.vprop ->
h0: Steel.Effect.Common.rmem frame ->
h1: Steel.Effect.Common.rmem frame ->
p: Type0
-> FStar.Pervasives.Lemma (requires h0 frame == h1 frame == p)
(ensures Steel.Effect.Common.frame_equalities' frame h0 h1 == p) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"FStar.PropositionalExtensionality.apply",
"Prims.unit",
"Steel.Effect.Common.lemma_frame_refl'",
"Prims.prop",
"Steel.Effect.Common.frame_equalities'",
"Prims.eq2",
"Steel.Effect.Common.normal",
"Steel.Effect.Common.t_of"
] | [] | true | false | true | false | false | let lemma_frame_equalities frame h0 h1 p =
| let p1:prop = h0 frame == h1 frame in
let p2:prop = frame_equalities' frame h0 h1 in
lemma_frame_refl' frame h0 h1;
FStar.PropositionalExtensionality.apply p1 p2 | false |
Steel.Effect.Common.fst | Steel.Effect.Common.star_commutative | val star_commutative (p1 p2:vprop)
: Lemma ((p1 `star` p2) `equiv` (p2 `star` p1)) | val star_commutative (p1 p2:vprop)
: Lemma ((p1 `star` p2) `equiv` (p2 `star` p1)) | let star_commutative p1 p2 = Mem.star_commutative (hp_of p1) (hp_of p2) | {
"file_name": "lib/steel/Steel.Effect.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 71,
"end_line": 110,
"start_col": 0,
"start_line": 110
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Semantics.Instantiate.fsti.checked",
"Steel.Semantics.Hoare.MST.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.PropositionalExtensionality.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.c... | [
{
"abbrev": true,
"full_module": "FStar.Algebra.CommMonoid.Equiv",
"short_module": "CE"
},
{
"abbrev": false,
"full_module": "FStar.Tactics.CanonCommMonoidSimple.Equiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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: Steel.Effect.Common.vprop -> p2: Steel.Effect.Common.vprop
-> FStar.Pervasives.Lemma
(ensures
Steel.Effect.Common.equiv (Steel.Effect.Common.star p1 p2) (Steel.Effect.Common.star p2 p1)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Memory.star_commutative",
"Steel.Effect.Common.hp_of",
"Prims.unit"
] | [] | true | false | true | false | false | let star_commutative p1 p2 =
| Mem.star_commutative (hp_of p1) (hp_of p2) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.