effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0 | val return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1)
let return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) = | false | null | false | fun s0 -> x, s0 | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.MSTTotal.repr",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val return (a: Type) (x: a) (state: Type u#2) (rel: P.preorder state)
: repr a state rel (fun _ -> True) (fun s0 r s1 -> r == x /\ s0 == s1) | [] | FStar.MSTTotal.return | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: Type -> x: a -> state: Type -> rel: FStar.Preorder.preorder state
-> FStar.MSTTotal.repr a state rel (fun _ -> Prims.l_True) (fun s0 r s1 -> r == x /\ s0 == s1) | {
"end_col": 17,
"end_line": 48,
"start_col": 2,
"start_line": 48
} |
FStar.MSTTotal.MSTATETOT | val put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATETOT unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let put (#state:Type u#2) (#rel:P.preorder state) (s:state)
: MSTATETOT unit state rel
(fun s0 -> rel s0 s)
(fun _ _ s1 -> s1 == s)
=
MSTATETOT?.reflect (fun _ -> (), s) | val put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATETOT unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s)
let put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATETOT unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) = | true | null | false | MSTATETOT?.reflect (fun _ -> (), s) | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [] | [
"FStar.Preorder.preorder",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Prims.eq2"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (b2t p ==> req_then s) /\ ((~ (b2t p)) ==> req_else s))
(fun s0 x s1 -> (b2t p ==> ens_then s0 x s1) /\ ((~ (b2t p)) ==> ens_else s0 x s1))
[@@ primitive_extraction]
total
reflectable
effect {
MSTATETOT (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATETOT state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1)
=
MSTATETOT?.reflect (fun s0 -> s0, s0)
[@@ noextract_to "krml"]
let put (#state:Type u#2) (#rel:P.preorder state) (s:state)
: MSTATETOT unit state rel
(fun s0 -> rel s0 s)
(fun _ _ s1 -> s1 == s) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val put (#state: Type u#2) (#rel: P.preorder state) (s: state)
: MSTATETOT unit state rel (fun s0 -> rel s0 s) (fun _ _ s1 -> s1 == s) | [] | FStar.MSTTotal.put | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | s: state -> FStar.MSTTotal.MSTATETOT Prims.unit | {
"end_col": 37,
"end_line": 129,
"start_col": 2,
"start_line": 129
} |
Prims.Pure | val subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f | val subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
let subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) = | false | null | false | f | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [] | [
"FStar.Preorder.preorder",
"FStar.MSTTotal.pre_t",
"FStar.MSTTotal.post_t",
"FStar.MSTTotal.repr",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_True"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val subcomp
(a: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: pre_t state)
(ens_g: post_t state a)
(f: repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True) | [] | FStar.MSTTotal.subcomp | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req_f: FStar.MSTTotal.pre_t state ->
ens_f: FStar.MSTTotal.post_t state a ->
req_g: FStar.MSTTotal.pre_t state ->
ens_g: FStar.MSTTotal.post_t state a ->
f: FStar.MSTTotal.repr a state rel req_f ens_f
-> Prims.Pure (FStar.MSTTotal.repr a state rel req_g ens_g) | {
"end_col": 3,
"end_line": 84,
"start_col": 2,
"start_line": 84
} |
Prims.Tot | val bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1 | val bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
let bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) = | false | null | false | fun s0 ->
let x, s1 = f s0 in
(g x) s1 | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [
"total"
] | [
"FStar.Preorder.preorder",
"FStar.MSTTotal.pre_t",
"FStar.MSTTotal.post_t",
"FStar.MSTTotal.repr",
"FStar.Pervasives.Native.tuple2",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_Exists"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bind
(a b: Type)
(state: Type u#2)
(rel: P.preorder state)
(req_f: pre_t state)
(ens_f: post_t state a)
(req_g: (a -> pre_t state))
(ens_g: (a -> post_t state b))
(f: repr a state rel req_f ens_f)
(g: (x: a -> repr b state rel (req_g x) (ens_g x)))
: repr b
state
rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2)) | [] | FStar.MSTTotal.bind | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
b: Type ->
state: Type ->
rel: FStar.Preorder.preorder state ->
req_f: FStar.MSTTotal.pre_t state ->
ens_f: FStar.MSTTotal.post_t state a ->
req_g: (_: a -> FStar.MSTTotal.pre_t state) ->
ens_g: (_: a -> FStar.MSTTotal.post_t state b) ->
f: FStar.MSTTotal.repr a state rel req_f ens_f ->
g: (x: a -> FStar.MSTTotal.repr b state rel (req_g x) (ens_g x))
-> FStar.MSTTotal.repr b
state
rel
(fun s0 -> req_f s0 /\ (forall (x: a) (s1: state). ens_f s0 x s1 ==> req_g x s1))
(fun s0 r s2 ->
req_f s0 /\ (exists (x: a) (s1: state). ens_f s0 x s1 /\ req_g x s1 /\ ens_g x s1 r s2)) | {
"end_col": 12,
"end_line": 67,
"start_col": 2,
"start_line": 65
} |
FStar.MSTTotal.MSTATETOT | val mst_tot_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mst_tot_assert (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1)
=
assert p | val mst_tot_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1)
let mst_tot_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) = | true | null | false | assert p | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [] | [
"FStar.Preorder.preorder",
"Prims._assert",
"Prims.unit",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (b2t p ==> req_then s) /\ ((~ (b2t p)) ==> req_else s))
(fun s0 x s1 -> (b2t p ==> ens_then s0 x s1) /\ ((~ (b2t p)) ==> ens_else s0 x s1))
[@@ primitive_extraction]
total
reflectable
effect {
MSTATETOT (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATETOT state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1)
=
MSTATETOT?.reflect (fun s0 -> s0, s0)
[@@ noextract_to "krml"]
let put (#state:Type u#2) (#rel:P.preorder state) (s:state)
: MSTATETOT unit state rel
(fun s0 -> rel s0 s)
(fun _ _ s1 -> s1 == s)
=
MSTATETOT?.reflect (fun _ -> (), s)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATETOT (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATETOT unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
let lift_pure_mst_total
(a:Type)
(wp:pure_wp a)
(state:Type u#2)
(rel:P.preorder state)
(f:eqtype_as_type unit -> PURE a wp)
: repr a state rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~ (wp (fun r -> r =!= x \/ s0 =!= s1))))
=
elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
x, s0
sub_effect PURE ~> MSTATETOT = lift_pure_mst_total
let mst_tot_assume (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATETOT unit state rel (fun _ -> True) (fun m0 _ m1 -> p /\ m0 == m1)
=
assume p
let mst_tot_admit (#state:Type u#2) (#rel:P.preorder state) (#a:Type) ()
: MSTATETOT a state rel (fun _ -> True) (fun _ _ _ -> False)
=
admit ()
let mst_tot_assert (#state:Type u#2) (#rel:P.preorder state) (p:Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mst_tot_assert (#state: Type u#2) (#rel: P.preorder state) (p: Type)
: MSTATETOT unit state rel (fun _ -> p) (fun m0 _ m1 -> p /\ m0 == m1) | [] | FStar.MSTTotal.mst_tot_assert | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | p: Type0 -> FStar.MSTTotal.MSTATETOT Prims.unit | {
"end_col": 10,
"end_line": 208,
"start_col": 2,
"start_line": 208
} |
FStar.MSTTotal.MSTATETOT | val get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATETOT state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATETOT state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1)
=
MSTATETOT?.reflect (fun s0 -> s0, s0) | val get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATETOT state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1)
let get (#state: Type u#2) (#rel: P.preorder state) ()
: MSTATETOT state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) = | true | null | false | MSTATETOT?.reflect (fun s0 -> s0, s0) | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [] | [
"FStar.Preorder.preorder",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (b2t p ==> req_then s) /\ ((~ (b2t p)) ==> req_else s))
(fun s0 x s1 -> (b2t p ==> ens_then s0 x s1) /\ ((~ (b2t p)) ==> ens_else s0 x s1))
[@@ primitive_extraction]
total
reflectable
effect {
MSTATETOT (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATETOT state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get: #state: Type u#2 -> #rel: P.preorder state -> Prims.unit
-> MSTATETOT state state rel (fun _ -> True) (fun s0 r s1 -> s0 == r /\ r == s1) | [] | FStar.MSTTotal.get | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.MSTTotal.MSTATETOT state | {
"end_col": 39,
"end_line": 121,
"start_col": 2,
"start_line": 121
} |
Prims.Tot | val lift_pure_mst_total
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1)))) | [
{
"abbrev": false,
"full_module": "FStar.Monotonic.Pure",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Preorder",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "FStar.Witnessed.Core",
"short_module": "W"
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lift_pure_mst_total
(a:Type)
(wp:pure_wp a)
(state:Type u#2)
(rel:P.preorder state)
(f:eqtype_as_type unit -> PURE a wp)
: repr a state rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~ (wp (fun r -> r =!= x \/ s0 =!= s1))))
=
elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
x, s0 | val lift_pure_mst_total
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1))))
let lift_pure_mst_total
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1)))) = | false | null | false | elim_pure_wp_monotonicity wp;
fun s0 ->
let x = f () in
x, s0 | {
"checked_file": "FStar.MSTTotal.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Witnessed.Core.fsti.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Pure.fst.checked"
],
"interface_file": false,
"source_file": "FStar.MSTTotal.fst"
} | [
"total"
] | [
"Prims.pure_wp",
"FStar.Preorder.preorder",
"FStar.Pervasives.eqtype_as_type",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Pure.elim_pure_wp_monotonicity",
"FStar.MSTTotal.repr",
"Prims.l_True",
"Prims.l_and",
"Prims.l_not",
"Prims.l_or",
"Prims.eq2"
] | [] | (*
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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.MSTTotal
module W = FStar.Witnessed.Core
module P = FStar.Preorder
open FStar.Monotonic.Pure
type pre_t (state:Type u#2) = state -> Type0
type post_t (state:Type u#2) (a:Type u#a) = state -> a -> state -> Type0
type repr
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
=
s0:state ->
PURE (a & state)
(as_pure_wp (fun p ->
req s0 /\
(forall (x:a) (s1:state). (ens s0 x s1 /\ rel s0 s1) ==> p (x, s1))))
let return
(a:Type)
(x:a)
(state:Type u#2)
(rel:P.preorder state)
: repr a state rel
(fun _ -> True)
(fun s0 r s1 -> r == x /\ s0 == s1)
=
fun s0 -> x, s0
let bind
(a:Type)
(b:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:a -> pre_t state)
(ens_g:a -> post_t state b)
(f:repr a state rel req_f ens_f)
(g:(x:a -> repr b state rel (req_g x) (ens_g x)))
: repr b state rel
(fun s0 -> req_f s0 /\ (forall x s1. ens_f s0 x s1 ==> (req_g x) s1))
(fun s0 r s2 -> req_f s0 /\ (exists x s1. ens_f s0 x s1 /\ (req_g x) s1 /\ (ens_g x) s1 r s2))
=
fun s0 ->
let x, s1 = f s0 in
(g x) s1
let subcomp
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_f:pre_t state)
(ens_f:post_t state a)
(req_g:pre_t state)
(ens_g:post_t state a)
(f:repr a state rel req_f ens_f)
: Pure (repr a state rel req_g ens_g)
(requires
(forall s. req_g s ==> req_f s) /\
(forall s0 x s1. (req_g s0 /\ ens_f s0 x s1) ==> ens_g s0 x s1))
(ensures fun _ -> True)
=
f
let if_then_else
(a:Type)
(state:Type u#2)
(rel:P.preorder state)
(req_then:pre_t state)
(ens_then:post_t state a)
(req_else:pre_t state)
(ens_else:post_t state a)
(f:repr a state rel req_then ens_then)
(g:repr a state rel req_else ens_else)
(p:bool)
: Type
=
repr a state rel
(fun s -> (b2t p ==> req_then s) /\ ((~ (b2t p)) ==> req_else s))
(fun s0 x s1 -> (b2t p ==> ens_then s0 x s1) /\ ((~ (b2t p)) ==> ens_else s0 x s1))
[@@ primitive_extraction]
total
reflectable
effect {
MSTATETOT (a:Type)
([@@@ effect_param] state:Type u#2)
([@@@ effect_param] rel:P.preorder state)
(req:pre_t state)
(ens:post_t state a)
with { repr; return; bind; subcomp; if_then_else }
}
[@@ noextract_to "krml"]
let get (#state:Type u#2) (#rel:P.preorder state) ()
: MSTATETOT state state rel
(fun _ -> True)
(fun s0 r s1 -> s0 == r /\ r == s1)
=
MSTATETOT?.reflect (fun s0 -> s0, s0)
[@@ noextract_to "krml"]
let put (#state:Type u#2) (#rel:P.preorder state) (s:state)
: MSTATETOT unit state rel
(fun s0 -> rel s0 s)
(fun _ _ s1 -> s1 == s)
=
MSTATETOT?.reflect (fun _ -> (), s)
assume
val witness (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
: MSTATETOT (W.witnessed state rel p) state rel
(fun s0 -> p s0 /\ W.stable state rel p)
(fun s0 _ s1 -> s0 == s1)
assume
val recall (state:Type u#2)
(rel:P.preorder state)
(p:W.s_predicate state)
(w:W.witnessed state rel p)
: MSTATETOT unit state rel
(fun _ -> True)
(fun s0 _ s1 -> s0 == s1 /\ p s1)
(*
* AR: why do we need the first conjunct in the postcondition?
*
* without this some proofs that use `assert e by t` fail
* the way `assert e by t` works is that, it is desugared into `with_tactic e t`
* that is abstract and remains in the VC as is at some point, we take a pass over
* the VC, find the `with_tactic e t` nodes in it, farm out `G |= e by t` where `G`
* is the context at that point in the VC in the original VC, `with_tactic e t`
* is simply replace by `True`.
* So why is it OK to replace it by `True`, don't we lose the fact that `e` holds for
* the rest of the VC?
* In the wp world of things, this works fine, since the wp of `assert e by t` is
* (fun _ -> with_tactic e t /\ (e ==> ...))
* i.e. the type of `assert e by t` already introduces a cut, so replacing it by
* `True` works fine.
*
* But this doesn't work when we use the intricate `~ (wp (fun r -> r =!= x))`
* combinator to convert from wp to pre post
*
* Basically, the shape of the VC in that case becomes:
* (with_tactic e t /\ (((~ with_tactic e t) \/ (e /\ ...)) ==> ...))
*
* In this VC, if we replace the first `with_tactic e t` with `True`, for the second conjunct,
* the solver can no longer reason that the first disjunct cannot hold
*
* The wp (fun _ -> True) below helps add that assumption to the second conjunct
*)
let lift_pure_mst_total
(a:Type)
(wp:pure_wp a)
(state:Type u#2)
(rel:P.preorder state)
(f:eqtype_as_type unit -> PURE a wp)
: repr a state rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~ (wp (fun r -> r =!= x \/ s0 =!= s1)))) | false | false | FStar.MSTTotal.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_pure_mst_total
(a: Type)
(wp: pure_wp a)
(state: Type u#2)
(rel: P.preorder state)
(f: (eqtype_as_type unit -> PURE a wp))
: repr a
state
rel
(fun s0 -> wp (fun _ -> True))
(fun s0 x s1 -> wp (fun _ -> True) /\ (~(wp (fun r -> r =!= x \/ s0 =!= s1)))) | [] | FStar.MSTTotal.lift_pure_mst_total | {
"file_name": "ulib/experimental/FStar.MSTTotal.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
a: Type ->
wp: Prims.pure_wp a ->
state: Type ->
rel: FStar.Preorder.preorder state ->
f: (_: FStar.Pervasives.eqtype_as_type Prims.unit -> Prims.PURE a)
-> FStar.MSTTotal.repr a
state
rel
(fun _ -> wp (fun _ -> Prims.l_True))
(fun s0 x s1 -> wp (fun _ -> Prims.l_True) /\ ~(wp (fun r -> ~(r == x) \/ ~(s0 == s1)))) | {
"end_col": 9,
"end_line": 190,
"start_col": 2,
"start_line": 187
} |
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let to_bv_tac () = focus (fun () ->
apply_lemma (`eq_to_bv);
apply_lemma (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ()
) | let to_bv_tac () = | true | null | false | focus (fun () ->
apply_lemma (`eq_to_bv);
apply_lemma (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ()) | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.focus",
"FStar.Tactics.BV.arith_to_bv_tac",
"FStar.Tactics.V2.Derived.apply_lemma"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y
let rec arith_expr_to_bv (e:expr) : Tac unit =
match e with
| NatToBv (MulMod e1 _) | MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _) | Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _) | Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _) | Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _) | Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2) | (Land e1 e2) ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2) | (Lxor e1 e2) ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2) | (Lor e1 e2) ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2) | (Ladd e1 e2) ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2) | (Lsub e1 e2) ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ ->
trefl ()
let arith_to_bv_tac () : Tac unit = focus (fun () ->
norm [delta_only ["FStar.BV.bvult"]];
let g = cur_goal () in
let f = term_as_formula g in
match f with
| Comp (Eq _) l r ->
begin match run_tm (as_arith_expr l) with
| Inl s ->
dump s;
trefl ()
| Inr e ->
// dump "inr arith_to_bv";
seq (fun () -> arith_expr_to_bv e) trefl
end
| _ ->
fail ("arith_to_bv_tac: unexpected: " ^ term_to_string g)
)
(* As things are right now, we need to be able to parse NatToBv
too. This can be useful, if we have mixed expressions so I'll leave it
as is for now *)
let bv_tac () = focus (fun () ->
mapply (`eq_to_bv);
mapply (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
norm [delta] ;
smt ()
)
let bv_tac_lt n = focus (fun () ->
let nn = pack (Tv_Const (C_Int n)) in
let t = mk_app (`trans_lt2) [(nn, Q_Implicit)] in
apply_lemma t;
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
smt ()
) | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val to_bv_tac : _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | [] | FStar.Tactics.BV.to_bv_tac | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 1,
"end_line": 206,
"start_col": 20,
"start_line": 201
} |
|
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bv_tac () = focus (fun () ->
mapply (`eq_to_bv);
mapply (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
norm [delta] ;
smt ()
) | let bv_tac () = | true | null | false | focus (fun () ->
mapply (`eq_to_bv);
mapply (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
norm [delta];
smt ()) | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.focus",
"FStar.Tactics.V2.Derived.smt",
"FStar.Tactics.V2.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta",
"Prims.Nil",
"FStar.Tactics.V2.Builtins.set_options",
"FStar.Tactics.BV.arith_to_bv_tac",
"FStar.Tactics.MApply.mapply",
"FStar.Reflection.Types.term",
"FStar.Tactics.MApply.termable_term"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y
let rec arith_expr_to_bv (e:expr) : Tac unit =
match e with
| NatToBv (MulMod e1 _) | MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _) | Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _) | Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _) | Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _) | Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2) | (Land e1 e2) ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2) | (Lxor e1 e2) ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2) | (Lor e1 e2) ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2) | (Ladd e1 e2) ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2) | (Lsub e1 e2) ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ ->
trefl ()
let arith_to_bv_tac () : Tac unit = focus (fun () ->
norm [delta_only ["FStar.BV.bvult"]];
let g = cur_goal () in
let f = term_as_formula g in
match f with
| Comp (Eq _) l r ->
begin match run_tm (as_arith_expr l) with
| Inl s ->
dump s;
trefl ()
| Inr e ->
// dump "inr arith_to_bv";
seq (fun () -> arith_expr_to_bv e) trefl
end
| _ ->
fail ("arith_to_bv_tac: unexpected: " ^ term_to_string g)
)
(* As things are right now, we need to be able to parse NatToBv
too. This can be useful, if we have mixed expressions so I'll leave it | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bv_tac : _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | [] | FStar.Tactics.BV.bv_tac | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 1,
"end_line": 189,
"start_col": 16,
"start_line": 181
} |
|
FStar.Tactics.Effect.Tac | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bv_tac_lt n = focus (fun () ->
let nn = pack (Tv_Const (C_Int n)) in
let t = mk_app (`trans_lt2) [(nn, Q_Implicit)] in
apply_lemma t;
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
smt ()
) | let bv_tac_lt n = | true | null | false | focus (fun () ->
let nn = pack (Tv_Const (C_Int n)) in
let t = mk_app (`trans_lt2) [(nn, Q_Implicit)] in
apply_lemma t;
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
smt ()) | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [] | [
"Prims.int",
"FStar.Tactics.V2.Derived.focus",
"Prims.unit",
"FStar.Tactics.V2.Derived.smt",
"FStar.Tactics.V2.Builtins.set_options",
"FStar.Tactics.BV.arith_to_bv_tac",
"FStar.Tactics.V2.Derived.apply_lemma",
"FStar.Reflection.Types.term",
"FStar.Reflection.V2.Derived.mk_app",
"Prims.Cons",
"FStar.Reflection.V2.Data.argv",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Reflection.V2.Data.aqualv",
"FStar.Reflection.V2.Data.Q_Implicit",
"Prims.Nil",
"FStar.Tactics.NamedView.term",
"FStar.Tactics.NamedView.pack",
"FStar.Tactics.NamedView.Tv_Const",
"FStar.Reflection.V2.Data.C_Int"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y
let rec arith_expr_to_bv (e:expr) : Tac unit =
match e with
| NatToBv (MulMod e1 _) | MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _) | Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _) | Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _) | Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _) | Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2) | (Land e1 e2) ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2) | (Lxor e1 e2) ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2) | (Lor e1 e2) ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2) | (Ladd e1 e2) ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2) | (Lsub e1 e2) ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ ->
trefl ()
let arith_to_bv_tac () : Tac unit = focus (fun () ->
norm [delta_only ["FStar.BV.bvult"]];
let g = cur_goal () in
let f = term_as_formula g in
match f with
| Comp (Eq _) l r ->
begin match run_tm (as_arith_expr l) with
| Inl s ->
dump s;
trefl ()
| Inr e ->
// dump "inr arith_to_bv";
seq (fun () -> arith_expr_to_bv e) trefl
end
| _ ->
fail ("arith_to_bv_tac: unexpected: " ^ term_to_string g)
)
(* As things are right now, we need to be able to parse NatToBv
too. This can be useful, if we have mixed expressions so I'll leave it
as is for now *)
let bv_tac () = focus (fun () ->
mapply (`eq_to_bv);
mapply (`trans);
arith_to_bv_tac ();
arith_to_bv_tac ();
set_options "--smtencoding.elim_box true";
norm [delta] ;
smt ()
) | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bv_tac_lt : n: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | [] | FStar.Tactics.BV.bv_tac_lt | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | n: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 1,
"end_line": 199,
"start_col": 18,
"start_line": 191
} |
|
FStar.Tactics.Effect.Tac | val arith_expr_to_bv (e: expr) : Tac unit | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec arith_expr_to_bv (e:expr) : Tac unit =
match e with
| NatToBv (MulMod e1 _) | MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _) | Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _) | Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _) | Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _) | Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2) | (Land e1 e2) ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2) | (Lxor e1 e2) ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2) | (Lor e1 e2) ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2) | (Ladd e1 e2) ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2) | (Lsub e1 e2) ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ ->
trefl () | val arith_expr_to_bv (e: expr) : Tac unit
let rec arith_expr_to_bv (e: expr) : Tac unit = | true | null | false | match e with
| NatToBv (MulMod e1 _)
| MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _)
| Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _)
| Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _)
| Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _)
| Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2)
| Land e1 e2 ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2)
| Lxor e1 e2 ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2)
| Lor e1 e2 ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2)
| Ladd e1 e2 ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2)
| Lsub e1 e2 ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ -> trefl () | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [] | [
"FStar.Reflection.V2.Arith.expr",
"FStar.Tactics.BV.arith_expr_to_bv",
"Prims.unit",
"FStar.Tactics.V2.Derived.apply_lemma",
"FStar.Tactics.V2.Derived.trefl"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val arith_expr_to_bv (e: expr) : Tac unit | [
"recursion"
] | FStar.Tactics.BV.arith_expr_to_bv | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | e: FStar.Reflection.V2.Arith.expr -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 16,
"end_line": 158,
"start_col": 4,
"start_line": 111
} |
FStar.Pervasives.Lemma | val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y) | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y | val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = | false | null | true | int2bv_lemma_2 #n x y | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.squash",
"Prims.eq2",
"FStar.BV.bv_t",
"FStar.BV.int2bv",
"FStar.BV.int2bv_lemma_2",
"Prims.unit"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y) | [] | FStar.Tactics.BV.eq_to_bv | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | pf: Prims.squash (FStar.BV.int2bv x == FStar.BV.int2bv y) -> FStar.Pervasives.Lemma (ensures x == y) | {
"end_col": 48,
"end_line": 85,
"start_col": 27,
"start_line": 85
} |
FStar.Tactics.Effect.Tac | val arith_to_bv_tac: Prims.unit -> Tac unit | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let arith_to_bv_tac () : Tac unit = focus (fun () ->
norm [delta_only ["FStar.BV.bvult"]];
let g = cur_goal () in
let f = term_as_formula g in
match f with
| Comp (Eq _) l r ->
begin match run_tm (as_arith_expr l) with
| Inl s ->
dump s;
trefl ()
| Inr e ->
// dump "inr arith_to_bv";
seq (fun () -> arith_expr_to_bv e) trefl
end
| _ ->
fail ("arith_to_bv_tac: unexpected: " ^ term_to_string g)
) | val arith_to_bv_tac: Prims.unit -> Tac unit
let arith_to_bv_tac () : Tac unit = | true | null | false | focus (fun () ->
norm [delta_only ["FStar.BV.bvult"]];
let g = cur_goal () in
let f = term_as_formula g in
match f with
| Comp (Eq _) l r ->
(match run_tm (as_arith_expr l) with
| Inl s ->
dump s;
trefl ()
| Inr e -> seq (fun () -> arith_expr_to_bv e) trefl)
| _ -> fail ("arith_to_bv_tac: unexpected: " ^ term_to_string g)) | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.focus",
"FStar.Pervasives.Native.option",
"FStar.Reflection.Types.typ",
"FStar.Tactics.NamedView.term",
"Prims.string",
"FStar.Tactics.V2.Derived.trefl",
"FStar.Tactics.V2.Builtins.dump",
"FStar.Reflection.V2.Arith.expr",
"FStar.Tactics.V2.Derived.seq",
"FStar.Tactics.BV.arith_expr_to_bv",
"FStar.Pervasives.either",
"FStar.Reflection.V2.Arith.run_tm",
"FStar.Reflection.V2.Arith.as_arith_expr",
"FStar.Reflection.V2.Formula.formula",
"FStar.Tactics.V2.Derived.fail",
"Prims.op_Hat",
"FStar.Tactics.V2.Builtins.term_to_string",
"FStar.Reflection.V2.Formula.term_as_formula",
"FStar.Tactics.V2.Derived.cur_goal",
"FStar.Tactics.V2.Builtins.norm",
"Prims.Cons",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.delta_only",
"Prims.Nil"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y
let rec arith_expr_to_bv (e:expr) : Tac unit =
match e with
| NatToBv (MulMod e1 _) | MulMod e1 _ ->
apply_lemma (`int2bv_mul);
apply_lemma (`cong_bvmul);
arith_expr_to_bv e1
| NatToBv (Umod e1 _) | Umod e1 _ ->
apply_lemma (`int2bv_mod);
apply_lemma (`cong_bvmod);
arith_expr_to_bv e1
| NatToBv (Udiv e1 _) | Udiv e1 _ ->
apply_lemma (`int2bv_div);
apply_lemma (`cong_bvdiv);
arith_expr_to_bv e1
| NatToBv (Shl e1 _) | Shl e1 _ ->
apply_lemma (`int2bv_shl);
apply_lemma (`cong_bvshl);
arith_expr_to_bv e1
| NatToBv (Shr e1 _) | Shr e1 _ ->
apply_lemma (`int2bv_shr);
apply_lemma (`cong_bvshr);
arith_expr_to_bv e1
| NatToBv (Land e1 e2) | (Land e1 e2) ->
apply_lemma (`int2bv_logand);
apply_lemma (`cong_bvand);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lxor e1 e2) | (Lxor e1 e2) ->
apply_lemma (`int2bv_logxor);
apply_lemma (`cong_bvxor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lor e1 e2) | (Lor e1 e2) ->
apply_lemma (`int2bv_logor);
apply_lemma (`cong_bvor);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Ladd e1 e2) | (Ladd e1 e2) ->
apply_lemma (`int2bv_add);
apply_lemma (`cong_bvadd);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| NatToBv (Lsub e1 e2) | (Lsub e1 e2) ->
apply_lemma (`int2bv_sub);
apply_lemma (`cong_bvsub);
arith_expr_to_bv e1;
arith_expr_to_bv e2
| _ ->
trefl () | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val arith_to_bv_tac: Prims.unit -> Tac unit | [] | FStar.Tactics.BV.arith_to_bv_tac | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | {
"end_col": 1,
"end_line": 176,
"start_col": 36,
"start_line": 160
} |
FStar.Pervasives.Lemma | val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y) | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = int2bv_lemma_ult_2 x y | val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y)
let trans_lt2 #n #x #y #z #w pf1 pf2 pf3 = | false | null | true | int2bv_lemma_ult_2 x y | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"FStar.BV.bv_t",
"Prims.squash",
"Prims.eq2",
"FStar.BV.int2bv",
"Prims.b2t",
"FStar.BV.bvult",
"FStar.BV.int2bv_lemma_ult_2",
"Prims.unit"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y
(* Creates two fresh variables and two equations of the form int2bv
x = z /\ int2bv y = w. The above lemmas transform these two
equations before finally instantiating them through reflexivity,
leaving Z3 to solve z = w *)
val trans: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (x == z) -> squash (y == w) -> squash (z == w) ->
Lemma (x == y)
let trans #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt: #n:pos -> (#x:bv_t n) -> (#y:bv_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
(eq2 #(bv_t n) x z) -> (eq2 #(bv_t n) y w) -> squash (bvult #n z w) ->
Lemma (bvult #n x y)
let trans_lt #n #x #y #z #w pf1 pf2 pf3 = ()
val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) -> | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val trans_lt2: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> (#z:bv_t n) -> (#w:bv_t n) ->
squash (int2bv #n x == z) -> squash (int2bv #n y == w) -> squash (bvult #n z w) ->
Lemma (x < y) | [] | FStar.Tactics.BV.trans_lt2 | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} |
pf1: Prims.squash (FStar.BV.int2bv x == z) ->
pf2: Prims.squash (FStar.BV.int2bv y == w) ->
pf3: Prims.squash (FStar.BV.bvult z w)
-> FStar.Pervasives.Lemma (ensures x < y) | {
"end_col": 65,
"end_line": 108,
"start_col": 43,
"start_line": 108
} |
FStar.Pervasives.Lemma | val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y) | [
{
"abbrev": false,
"full_module": "FStar.UInt",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.BV",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Arith",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V2.Formula",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lt_to_bv #n #x #y pf = int2bv_lemma_ult_2 #n x y | val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y)
let lt_to_bv #n #x #y pf = | false | null | true | int2bv_lemma_ult_2 #n x y | {
"checked_file": "FStar.Tactics.BV.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Reflection.V2.Formula.fst.checked",
"FStar.Reflection.V2.Arith.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.BV.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Tactics.BV.fst"
} | [
"lemma"
] | [
"Prims.pos",
"FStar.UInt.uint_t",
"Prims.b2t",
"FStar.BV.bvult",
"FStar.BV.int2bv",
"FStar.BV.int2bv_lemma_ult_2",
"Prims.unit"
] | [] | (*
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 agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Tactics.BV
open FStar.Tactics.V2
open FStar.Reflection.V2.Formula
open FStar.Reflection.V2.Arith
open FStar.BV
open FStar.UInt
// using uint_t' instead of uint_t breaks the tactic (goes to inl).
(* Congruence lemmas *)
val cong_bvand : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvand #n w x == bvand #n y z)
let cong_bvand #n #w #x #y #z pf1 pf2 = ()
val cong_bvxor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvxor w x == bvxor y z)
let cong_bvxor #n #w #x #y #z pf1 pf2 = ()
val cong_bvor : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvor w x == bvor y z)
let cong_bvor #n #w #x #y #z pf1 pf2 = ()
val cong_bvshl : #n:pos -> (#w:bv_t n) -> (#x:uint_t n) ->
(#y:bv_t n) -> squash (w == y) ->
Lemma (bvshl w x == bvshl y x)
let cong_bvshl #n #w #x #y pf = ()
val cong_bvshr : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvshr #n w x == bvshr #n y x)
let cong_bvshr #n #w #x #y pf = ()
val cong_bvdiv : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvdiv #n w x == bvdiv #n y x)
let cong_bvdiv #n #w #x #y pf = ()
val cong_bvmod : #n:pos -> #w:bv_t n -> (#x:uint_t n{x <> 0}) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmod #n w x == bvmod #n y x)
let cong_bvmod #n #w #x #y pf = ()
val cong_bvmul : #n:pos -> #w:bv_t n -> (#x:uint_t n) ->
#y:bv_t n -> squash (w == y) ->
Lemma (bvmul #n w x == bvmul #n y x)
let cong_bvmul #n #w #x #y pf = ()
val cong_bvadd : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvadd w x == bvadd y z)
let cong_bvadd #n #w #x #y #z pf1 pf2 = ()
val cong_bvsub : #n:pos -> (#w:bv_t n) -> (#x:bv_t n) ->
(#y:bv_t n) -> (#z:bv_t n) ->
squash (w == y) -> squash (x == z) ->
Lemma (bvsub w x == bvsub y z)
let cong_bvsub #n #w #x #y #z pf1 pf2 = ()
(* Used to reduce the initial equation to an equation on bitvectors*)
val eq_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
squash (int2bv #n x == int2bv #n y) -> Lemma (x == y)
let eq_to_bv #n #x #y pf = int2bv_lemma_2 #n x y
val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) -> | false | false | FStar.Tactics.BV.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lt_to_bv: #n:pos -> (#x:uint_t n) -> (#y:uint_t n) ->
(b2t (bvult #n (int2bv #n x) (int2bv #n y))) -> Lemma (x < y) | [] | FStar.Tactics.BV.lt_to_bv | {
"file_name": "ulib/FStar.Tactics.BV.fst",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | pf: FStar.BV.bvult (FStar.BV.int2bv x) (FStar.BV.int2bv y) -> FStar.Pervasives.Lemma (ensures x < y) | {
"end_col": 52,
"end_line": 89,
"start_col": 27,
"start_line": 89
} |
FStar.HyperStack.ST.Stack | val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec do_while inv f =
if not (f ()) then
do_while inv f | val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f = | true | null | false | if not (f ()) then do_while inv f | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.bool",
"Prims.unit",
"Prims.l_and",
"C.Loops.do_while",
"Prims.op_Negation"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true)) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true)) | [
"recursion"
] | C.Loops.do_while | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.bool -> Prims.GTot Type0) ->
f: (_: Prims.unit -> FStar.HyperStack.ST.Stack Prims.bool)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 18,
"end_line": 148,
"start_col": 2,
"start_line": 147
} |
FStar.HyperStack.ST.Stack | val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end | val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body = | true | null | false | if test ()
then
(body ();
while #test_pre #test_post test body) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.Monotonic.HyperStack.mem",
"Prims.bool",
"Prims.unit",
"C.Loops.while"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1)) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1)) | [
"recursion"
] | C.Loops.while | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
$test: (_: Prims.unit -> FStar.HyperStack.ST.Stack Prims.bool) ->
body: (_: Prims.unit -> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 5,
"end_line": 172,
"start_col": 2,
"start_line": 169
} |
Prims.Pure | val total_while_gen
(#t: Type)
(#a: (t -> Type))
(tmes: (x: t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t
-> Pure t
(requires (tinv true x))
(ensures
(fun y ->
tinv (tcontinue y) y /\ (if tcontinue y then tmes y << tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec total_while_gen
(#t: Type)
(#a:t -> Type)
(tmes: (x:t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t) ->
Pure t
(requires (tinv true x))
(ensures (fun y ->
tinv (tcontinue y) y /\ (
if tcontinue y then tmes y << tmes x else True)
)))
(x: t)
: Pure t
(requires (tinv true x))
(ensures (fun y -> tinv false y))
(decreases (tmes x))
= let y = body x in
let continue = tcontinue y in
if continue
then total_while_gen tmes tinv tcontinue body y
else y | val total_while_gen
(#t: Type)
(#a: (t -> Type))
(tmes: (x: t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t
-> Pure t
(requires (tinv true x))
(ensures
(fun y ->
tinv (tcontinue y) y /\ (if tcontinue y then tmes y << tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x))
let rec total_while_gen
(#t: Type)
(#a: (t -> Type))
(tmes: (x: t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t
-> Pure t
(requires (tinv true x))
(ensures
(fun y ->
tinv (tcontinue y) y /\ (if tcontinue y then tmes y << tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) = | false | null | false | let y = body x in
let continue = tcontinue y in
if continue then total_while_gen tmes tinv tcontinue body y else y | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [
""
] | [
"Prims.bool",
"Prims.l_and",
"Prims.precedes",
"Prims.l_True",
"Prims.logical",
"C.Loops.total_while_gen"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
inline_for_extraction
let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b))
(** Extracts as (destination buffer comes first):
* for (int i = 0; i < <l>; ++i)
* in1[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let in_place_map2 #a #b in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j)
/\ (forall (j:nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
#reset-options "--initial_fuel 2 --max_fuel 2 --z3rlimit 20"
(* Repeating the same operation a number of times over a buffer ***************)
#reset-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** To be extracted as:
* for (int i = 0; i < n; ++i)
* f(b);
*)
inline_for_extraction
val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) ))
inline_for_extraction
let repeat #a l f b max fc =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v max
/\ as_seq h1 b == Spec.Loops.repeat i f (as_seq h0 b)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
fc b;
Spec.Loops.repeat_induction (UInt32.v i + 1) f (as_seq h0 b)
in
Spec.Loops.repeat_base 0 f (as_seq h0 b);
for 0ul max inv f'
(** Implementation of Spec.Loops.repeat_range *)
(** The type of the specification of the loop body (the function f
given to Spec.Loops.repeat_range *)
inline_for_extraction
let repeat_range_body_spec
(a: Type0)
(max: nat)
: Tot Type
= (a -> i:nat{i < max} -> Tot a)
(** The type of the semantics (interpretation) of a memory state as a
value of the type `a` of the high-level state on which the loop
body specification operates *)
inline_for_extraction
let repeat_range_body_interp
(a: Type0)
(inv: (HS.mem -> GTot Type0))
: Tot Type
= (h: HS.mem { inv h } ) ->
GTot a
(** The type of the implementation of the loop body, proven correct
with respect to the corresponding specification `f` *)
inline_for_extraction
let repeat_range_body_impl
(#a:Type0)
(min:UInt32.t)
(max:UInt32.t{UInt32.v min <= UInt32.v max})
(f: Ghost.erased (repeat_range_body_spec a (UInt32.v max)))
(inv: (HS.mem -> GTot Type0))
(interp: repeat_range_body_interp a inv)
: Tot Type
= (i:UInt32.t{UInt32.v min <= UInt32.v i /\ UInt32.v i < UInt32.v max}) ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h0 _ h1 ->
inv h0 /\ inv h1 /\
interp h1 == (Ghost.reveal f) (interp h0) (UInt32.v i)
))
(** The implementation of the actual loop
To be extracted as:
for (int i = min; i < max; ++i)
f(b, i);
This combinator is generic. Typically, the interpretation reads the
contents of a few objects (buffers, references, etc.), and the
invariant contains a modifies clause that asserts that only those
objects are modified, and that they are live.
*)
inline_for_extraction
val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
))
inline_for_extraction
let repeat_range #a min max f inv interp fc =
let h0 = HST.get() in
let inv' (h1: HS.mem) (i: nat): Type0 =
inv h1 /\
i <= UInt32.v max /\ UInt32.v min <= i /\
interp h1 == Spec.Loops.repeat_range (UInt32.v min) i (Ghost.reveal f) (interp h0)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): HST.Stack unit
(requires (fun h -> inv' h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv' h_2 (v i + 1))))
=
fc i;
Spec.Loops.repeat_range_induction (UInt32.v min) (UInt32.v i + 1) (Ghost.reveal f) (interp h0)
in
Spec.Loops.repeat_range_base (UInt32.v min) (Ghost.reveal f) (interp h0);
for min max inv' f'
let rec total_while_gen
(#t: Type)
(#a:t -> Type)
(tmes: (x:t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t) ->
Pure t
(requires (tinv true x))
(ensures (fun y ->
tinv (tcontinue y) y /\ (
if tcontinue y then tmes y << tmes x else True)
)))
(x: t)
: Pure t
(requires (tinv true x))
(ensures (fun y -> tinv false y)) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val total_while_gen
(#t: Type)
(#a: (t -> Type))
(tmes: (x: t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t
-> Pure t
(requires (tinv true x))
(ensures
(fun y ->
tinv (tcontinue y) y /\ (if tcontinue y then tmes y << tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) | [
"recursion"
] | C.Loops.total_while_gen | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
tmes: (x: t -> Prims.GTot (a x)) ->
tinv: (_: Prims.bool -> _: t -> Prims.GTot Type0) ->
tcontinue: (_: t -> Prims.bool) ->
body: (x: t -> Prims.Pure t) ->
x: t
-> Prims.Pure t | {
"end_col": 8,
"end_line": 527,
"start_col": 1,
"start_line": 523
} |
Prims.Pure | val total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t
-> Pure (bool * t)
(requires (tinv true x))
(ensures
(fun (continue, y) ->
tinv continue y /\ (if continue then tmes y < tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t) ->
Pure (bool * t)
(requires (tinv true x))
(ensures (fun (continue, y) ->
tinv continue y /\ (
if continue then tmes y < tmes x else True)
)))
(x: t)
: Pure t
(requires (tinv true x))
(ensures (fun y -> tinv false y))
(decreases (tmes x))
= let (_, res) =
total_while_gen
(fun (_, x) -> tmes x)
(fun b (b_, x) -> b == b_ /\ tinv b x)
(fun (x, _) -> x)
(fun (_, x) -> body x)
(true, x)
in
res | val total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t
-> Pure (bool * t)
(requires (tinv true x))
(ensures
(fun (continue, y) ->
tinv continue y /\ (if continue then tmes y < tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x))
let total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t
-> Pure (bool * t)
(requires (tinv true x))
(ensures
(fun (continue, y) ->
tinv continue y /\ (if continue then tmes y < tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) = | false | null | false | let _, res =
total_while_gen (fun (_, x) -> tmes x)
(fun b (b_, x) -> b == b_ /\ tinv b x)
(fun (x, _) -> x)
(fun (_, x) -> body x)
(true, x)
in
res | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [
""
] | [
"Prims.nat",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_True",
"Prims.logical",
"C.Loops.total_while_gen",
"Prims.eq2",
"FStar.Pervasives.Native.Mktuple2"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
inline_for_extraction
let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b))
(** Extracts as (destination buffer comes first):
* for (int i = 0; i < <l>; ++i)
* in1[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let in_place_map2 #a #b in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j)
/\ (forall (j:nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
#reset-options "--initial_fuel 2 --max_fuel 2 --z3rlimit 20"
(* Repeating the same operation a number of times over a buffer ***************)
#reset-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** To be extracted as:
* for (int i = 0; i < n; ++i)
* f(b);
*)
inline_for_extraction
val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) ))
inline_for_extraction
let repeat #a l f b max fc =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v max
/\ as_seq h1 b == Spec.Loops.repeat i f (as_seq h0 b)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
fc b;
Spec.Loops.repeat_induction (UInt32.v i + 1) f (as_seq h0 b)
in
Spec.Loops.repeat_base 0 f (as_seq h0 b);
for 0ul max inv f'
(** Implementation of Spec.Loops.repeat_range *)
(** The type of the specification of the loop body (the function f
given to Spec.Loops.repeat_range *)
inline_for_extraction
let repeat_range_body_spec
(a: Type0)
(max: nat)
: Tot Type
= (a -> i:nat{i < max} -> Tot a)
(** The type of the semantics (interpretation) of a memory state as a
value of the type `a` of the high-level state on which the loop
body specification operates *)
inline_for_extraction
let repeat_range_body_interp
(a: Type0)
(inv: (HS.mem -> GTot Type0))
: Tot Type
= (h: HS.mem { inv h } ) ->
GTot a
(** The type of the implementation of the loop body, proven correct
with respect to the corresponding specification `f` *)
inline_for_extraction
let repeat_range_body_impl
(#a:Type0)
(min:UInt32.t)
(max:UInt32.t{UInt32.v min <= UInt32.v max})
(f: Ghost.erased (repeat_range_body_spec a (UInt32.v max)))
(inv: (HS.mem -> GTot Type0))
(interp: repeat_range_body_interp a inv)
: Tot Type
= (i:UInt32.t{UInt32.v min <= UInt32.v i /\ UInt32.v i < UInt32.v max}) ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h0 _ h1 ->
inv h0 /\ inv h1 /\
interp h1 == (Ghost.reveal f) (interp h0) (UInt32.v i)
))
(** The implementation of the actual loop
To be extracted as:
for (int i = min; i < max; ++i)
f(b, i);
This combinator is generic. Typically, the interpretation reads the
contents of a few objects (buffers, references, etc.), and the
invariant contains a modifies clause that asserts that only those
objects are modified, and that they are live.
*)
inline_for_extraction
val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
))
inline_for_extraction
let repeat_range #a min max f inv interp fc =
let h0 = HST.get() in
let inv' (h1: HS.mem) (i: nat): Type0 =
inv h1 /\
i <= UInt32.v max /\ UInt32.v min <= i /\
interp h1 == Spec.Loops.repeat_range (UInt32.v min) i (Ghost.reveal f) (interp h0)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): HST.Stack unit
(requires (fun h -> inv' h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv' h_2 (v i + 1))))
=
fc i;
Spec.Loops.repeat_range_induction (UInt32.v min) (UInt32.v i + 1) (Ghost.reveal f) (interp h0)
in
Spec.Loops.repeat_range_base (UInt32.v min) (Ghost.reveal f) (interp h0);
for min max inv' f'
let rec total_while_gen
(#t: Type)
(#a:t -> Type)
(tmes: (x:t -> GTot (a x)))
(tinv: (bool -> t -> GTot Type0))
(tcontinue: (t -> Tot bool))
(body:
(x: t) ->
Pure t
(requires (tinv true x))
(ensures (fun y ->
tinv (tcontinue y) y /\ (
if tcontinue y then tmes y << tmes x else True)
)))
(x: t)
: Pure t
(requires (tinv true x))
(ensures (fun y -> tinv false y))
(decreases (tmes x))
= let y = body x in
let continue = tcontinue y in
if continue
then total_while_gen tmes tinv tcontinue body y
else y
inline_for_extraction
let total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t) ->
Pure (bool * t)
(requires (tinv true x))
(ensures (fun (continue, y) ->
tinv continue y /\ (
if continue then tmes y < tmes x else True)
)))
(x: t)
: Pure t
(requires (tinv true x))
(ensures (fun y -> tinv false y)) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val total_while
(#t: Type)
(tmes: (t -> GTot nat))
(tinv: (bool -> t -> GTot Type0))
(body:
(x: t
-> Pure (bool * t)
(requires (tinv true x))
(ensures
(fun (continue, y) ->
tinv continue y /\ (if continue then tmes y < tmes x else True)))))
(x: t)
: Pure t (requires (tinv true x)) (ensures (fun y -> tinv false y)) (decreases (tmes x)) | [] | C.Loops.total_while | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
tmes: (_: t -> Prims.GTot Prims.nat) ->
tinv: (_: Prims.bool -> _: t -> Prims.GTot Type0) ->
body: (x: t -> Prims.Pure (Prims.bool * t)) ->
x: t
-> Prims.Pure t | {
"end_col": 5,
"end_line": 555,
"start_col": 1,
"start_line": 547
} |
FStar.HyperStack.ST.Stack | val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end | val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f = | true | null | false | if start = finish
then ()
else
(f start;
for64 (let open UInt64 in start +^ 1uL) finish inv f) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt64.t",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt64.v",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.unit",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"C.Loops.for64",
"FStar.UInt64.op_Plus_Hat",
"FStar.UInt64.__uint_to_t"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish))) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish))) | [
"recursion"
] | C.Loops.for64 | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
start: FStar.UInt64.t ->
finish: FStar.UInt64.t{FStar.UInt64.v finish >= FStar.UInt64.v start} ->
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.nat -> Type0) ->
f:
(
i:
FStar.UInt64.t
{ FStar.UInt64.v start <= FStar.UInt64.v i /\
FStar.UInt64.v i < FStar.UInt64.v finish }
-> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 5,
"end_line": 78,
"start_col": 2,
"start_line": 73
} |
FStar.HyperStack.ST.Stack | val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end | val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f = | true | null | false | if start = finish
then ()
else
(f start;
for (let open UInt32 in start +^ 1ul) finish inv f) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.unit",
"Prims.op_Addition",
"Prims.op_Equality",
"Prims.bool",
"C.Loops.for",
"FStar.UInt32.op_Plus_Hat",
"FStar.UInt32.__uint_to_t"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | [
"recursion"
] | C.Loops.for | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
start: FStar.UInt32.t ->
finish: FStar.UInt32.t{FStar.UInt32.v finish >= FStar.UInt32.v start} ->
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.nat -> Type0) ->
f:
(
i:
FStar.UInt32.t
{ FStar.UInt32.v start <= FStar.UInt32.v i /\
FStar.UInt32.v i < FStar.UInt32.v finish }
-> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 5,
"end_line": 60,
"start_col": 2,
"start_line": 55
} |
FStar.HyperStack.ST.Stack | val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end | val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f = | true | null | false | if start = finish
then ()
else
(f start;
reverse_for (let open UInt32 in start -^ 1ul) finish inv f) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"Prims.unit",
"Prims.op_Subtraction",
"Prims.op_Equality",
"Prims.bool",
"C.Loops.reverse_for",
"FStar.UInt32.op_Subtraction_Hat",
"FStar.UInt32.__uint_to_t"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish))) | [
"recursion"
] | C.Loops.reverse_for | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
start: FStar.UInt32.t ->
finish: FStar.UInt32.t{FStar.UInt32.v finish <= FStar.UInt32.v start} ->
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.nat -> Type0) ->
f:
(
i:
FStar.UInt32.t
{ FStar.UInt32.v start >= FStar.UInt32.v i /\
FStar.UInt32.v i > FStar.UInt32.v finish }
-> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 5,
"end_line": 101,
"start_col": 2,
"start_line": 96
} |
FStar.HyperStack.ST.Stack | val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f | val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f = | true | null | false | if start = finish
then (finish, false)
else
let start' = let open UInt32 in start +^ 1ul in
if f start then (start', true) else interruptible_for start' finish inv f | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.bool",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Equality",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"C.Loops.interruptible_for",
"FStar.UInt32.op_Plus_Hat",
"FStar.UInt32.__uint_to_t"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | [
"recursion"
] | C.Loops.interruptible_for | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
start: FStar.UInt32.t ->
finish: FStar.UInt32.t{FStar.UInt32.v finish >= FStar.UInt32.v start} ->
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.nat -> _: Prims.bool -> Prims.GTot Type0) ->
f:
(
i:
FStar.UInt32.t
{ FStar.UInt32.v start <= FStar.UInt32.v i /\
FStar.UInt32.v i < FStar.UInt32.v finish }
-> FStar.HyperStack.ST.Stack Prims.bool)
-> FStar.HyperStack.ST.Stack (FStar.UInt32.t * Prims.bool) | {
"end_col": 46,
"end_line": 128,
"start_col": 2,
"start_line": 122
} |
FStar.HyperStack.ST.Stack | val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f | val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f = | true | null | false | if start = finish
then (finish, false)
else
let start' = let open UInt32 in start -^ 1ul in
if f start then (start', true) else interruptible_reverse_for start' finish inv f | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"Prims.bool",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.op_Equality",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"C.Loops.interruptible_reverse_for",
"FStar.UInt32.op_Subtraction_Hat",
"FStar.UInt32.__uint_to_t"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b))) | [
"recursion"
] | C.Loops.interruptible_reverse_for | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
start: FStar.UInt32.t ->
finish: FStar.UInt32.t{FStar.UInt32.v finish <= FStar.UInt32.v start} ->
inv: (_: FStar.Monotonic.HyperStack.mem -> _: Prims.nat -> _: Prims.bool -> Prims.GTot Type0) ->
f:
(
i:
FStar.UInt32.t
{ FStar.UInt32.v start >= FStar.UInt32.v i /\
FStar.UInt32.v i > FStar.UInt32.v finish }
-> FStar.HyperStack.ST.Stack Prims.bool)
-> FStar.HyperStack.ST.Stack (FStar.UInt32.t * Prims.bool) | {
"end_col": 54,
"end_line": 200,
"start_col": 2,
"start_line": 194
} |
FStar.HyperStack.ST.Stack | val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
)) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repeat_range #a min max f inv interp fc =
let h0 = HST.get() in
let inv' (h1: HS.mem) (i: nat): Type0 =
inv h1 /\
i <= UInt32.v max /\ UInt32.v min <= i /\
interp h1 == Spec.Loops.repeat_range (UInt32.v min) i (Ghost.reveal f) (interp h0)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): HST.Stack unit
(requires (fun h -> inv' h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv' h_2 (v i + 1))))
=
fc i;
Spec.Loops.repeat_range_induction (UInt32.v min) (UInt32.v i + 1) (Ghost.reveal f) (interp h0)
in
Spec.Loops.repeat_range_base (UInt32.v min) (Ghost.reveal f) (interp h0);
for min max inv' f' | val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
))
let repeat_range #a min max f inv interp fc = | true | null | false | let h0 = HST.get () in
let inv' (h1: HS.mem) (i: nat) : Type0 =
inv h1 /\ i <= UInt32.v max /\ UInt32.v min <= i /\
interp h1 == Spec.Loops.repeat_range (UInt32.v min) i (Ghost.reveal f) (interp h0)
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v max})
: HST.Stack unit
(requires (fun h -> inv' h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv' h_2 (v i + 1))) =
fc i;
Spec.Loops.repeat_range_induction (UInt32.v min) (UInt32.v i + 1) (Ghost.reveal f) (interp h0)
in
Spec.Loops.repeat_range_base (UInt32.v min) (Ghost.reveal f) (interp h0);
for min max inv' f' | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"FStar.Ghost.erased",
"C.Loops.repeat_range_body_spec",
"FStar.Monotonic.HyperStack.mem",
"C.Loops.repeat_range_body_interp",
"C.Loops.repeat_range_body_impl",
"C.Loops.for",
"Prims.unit",
"Spec.Loops.repeat_range_base",
"FStar.Ghost.reveal",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_Addition",
"Spec.Loops.repeat_range_induction",
"Prims.nat",
"Prims.eq2",
"Spec.Loops.repeat_range",
"FStar.HyperStack.ST.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
inline_for_extraction
let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b))
(** Extracts as (destination buffer comes first):
* for (int i = 0; i < <l>; ++i)
* in1[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let in_place_map2 #a #b in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j)
/\ (forall (j:nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
#reset-options "--initial_fuel 2 --max_fuel 2 --z3rlimit 20"
(* Repeating the same operation a number of times over a buffer ***************)
#reset-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** To be extracted as:
* for (int i = 0; i < n; ++i)
* f(b);
*)
inline_for_extraction
val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) ))
inline_for_extraction
let repeat #a l f b max fc =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v max
/\ as_seq h1 b == Spec.Loops.repeat i f (as_seq h0 b)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
fc b;
Spec.Loops.repeat_induction (UInt32.v i + 1) f (as_seq h0 b)
in
Spec.Loops.repeat_base 0 f (as_seq h0 b);
for 0ul max inv f'
(** Implementation of Spec.Loops.repeat_range *)
(** The type of the specification of the loop body (the function f
given to Spec.Loops.repeat_range *)
inline_for_extraction
let repeat_range_body_spec
(a: Type0)
(max: nat)
: Tot Type
= (a -> i:nat{i < max} -> Tot a)
(** The type of the semantics (interpretation) of a memory state as a
value of the type `a` of the high-level state on which the loop
body specification operates *)
inline_for_extraction
let repeat_range_body_interp
(a: Type0)
(inv: (HS.mem -> GTot Type0))
: Tot Type
= (h: HS.mem { inv h } ) ->
GTot a
(** The type of the implementation of the loop body, proven correct
with respect to the corresponding specification `f` *)
inline_for_extraction
let repeat_range_body_impl
(#a:Type0)
(min:UInt32.t)
(max:UInt32.t{UInt32.v min <= UInt32.v max})
(f: Ghost.erased (repeat_range_body_spec a (UInt32.v max)))
(inv: (HS.mem -> GTot Type0))
(interp: repeat_range_body_interp a inv)
: Tot Type
= (i:UInt32.t{UInt32.v min <= UInt32.v i /\ UInt32.v i < UInt32.v max}) ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h0 _ h1 ->
inv h0 /\ inv h1 /\
interp h1 == (Ghost.reveal f) (interp h0) (UInt32.v i)
))
(** The implementation of the actual loop
To be extracted as:
for (int i = min; i < max; ++i)
f(b, i);
This combinator is generic. Typically, the interpretation reads the
contents of a few objects (buffers, references, etc.), and the
invariant contains a modifies clause that asserts that only those
objects are modified, and that they are live.
*)
inline_for_extraction
val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
)) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repeat_range:
#a:Type0 ->
min:UInt32.t ->
max:UInt32.t{UInt32.v min <= UInt32.v max} ->
f: (Ghost.erased (repeat_range_body_spec a (UInt32.v max))) ->
inv: (HS.mem -> GTot Type0) ->
interp: repeat_range_body_interp a inv ->
fc: repeat_range_body_impl min max f inv interp ->
HST.Stack unit
(requires (fun h -> inv h))
(ensures (fun h_1 _ h_2 ->
inv h_1 /\ inv h_2 /\
interp h_2 == Spec.Loops.repeat_range (UInt32.v min) (UInt32.v max) (Ghost.reveal f) (interp h_1)
)) | [] | C.Loops.repeat_range | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
min: FStar.UInt32.t ->
max: FStar.UInt32.t{FStar.UInt32.v min <= FStar.UInt32.v max} ->
f: FStar.Ghost.erased (C.Loops.repeat_range_body_spec a (FStar.UInt32.v max)) ->
inv: (_: FStar.Monotonic.HyperStack.mem -> Prims.GTot Type0) ->
interp: C.Loops.repeat_range_body_interp a inv ->
fc: C.Loops.repeat_range_body_impl min max f inv interp
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 21,
"end_line": 501,
"start_col": 45,
"start_line": 486
} |
FStar.HyperStack.ST.Stack | val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) )) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b)) | val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
let in_place_map #a b l f = | true | null | false | let h0 = HST.get () in
let inv (h1: HS.mem) (i: nat) : Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l /\
(forall (j: nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j) /\
(forall (j: nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v l})
: Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv h_2 (v i + 1))) =
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get () in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b)) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt32.t",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"FStar.Seq.Base.lemma_eq_intro",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Loops.seq_map",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowStar.BufferOps.op_Array_Assignment",
"LowStar.BufferOps.op_Array_Access",
"Prims.nat",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) )) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) )) | [] | C.Loops.in_place_map | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
b: LowStar.Buffer.buffer a ->
l: FStar.UInt32.t{FStar.UInt32.v l = LowStar.Monotonic.Buffer.length b} ->
f: (_: a -> a)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 60,
"end_line": 317,
"start_col": 27,
"start_line": 301
} |
FStar.HyperStack.ST.Stack | val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) )) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input)) | val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
let map #a #b output input l f = | true | null | false | let h0 = HST.get () in
let inv (h1: HS.mem) (i: nat) : Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l /\
(forall (j: nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j) /\
(forall (j: nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v l})
: Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv h_2 (v i + 1))) =
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get () in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input)) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"FStar.Seq.Base.lemma_eq_intro",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Loops.seq_map",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowStar.BufferOps.op_Array_Assignment",
"LowStar.BufferOps.op_Array_Access",
"Prims.nat",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) )) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) )) | [] | C.Loops.map | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
output: LowStar.Buffer.buffer b ->
input: LowStar.Buffer.buffer a {LowStar.Monotonic.Buffer.disjoint input output} ->
l:
FStar.UInt32.t
{ FStar.UInt32.v l = LowStar.Monotonic.Buffer.length output /\
FStar.UInt32.v l = LowStar.Monotonic.Buffer.length input } ->
f: (_: a -> b)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 69,
"end_line": 240,
"start_col": 32,
"start_line": 224
} |
FStar.HyperStack.ST.Stack | val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) )) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let repeat #a l f b max fc =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v max
/\ as_seq h1 b == Spec.Loops.repeat i f (as_seq h0 b)
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v max ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
fc b;
Spec.Loops.repeat_induction (UInt32.v i + 1) f (as_seq h0 b)
in
Spec.Loops.repeat_base 0 f (as_seq h0 b);
for 0ul max inv f' | val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) ))
let repeat #a l f b max fc = | true | null | false | let h0 = HST.get () in
let inv (h1: HS.mem) (i: nat) : Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v max /\
as_seq h1 b == Spec.Loops.repeat i f (as_seq h0 b)
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v max})
: Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv h_2 (v i + 1))) =
fc b;
Spec.Loops.repeat_induction (UInt32.v i + 1) f (as_seq h0 b)
in
Spec.Loops.repeat_base 0 f (as_seq h0 b);
for 0ul max inv f' | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"FStar.UInt32.t",
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"FStar.UInt32.v",
"Prims.nat",
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.length",
"LowStar.Buffer.trivial_preorder",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"LowStar.Monotonic.Buffer.live",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.eq2",
"LowStar.Monotonic.Buffer.as_seq",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Spec.Loops.repeat_base",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"Spec.Loops.repeat_induction",
"Spec.Loops.repeat",
"FStar.HyperStack.ST.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
inline_for_extraction
let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b))
(** Extracts as (destination buffer comes first):
* for (int i = 0; i < <l>; ++i)
* in1[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let in_place_map2 #a #b in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j)
/\ (forall (j:nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
#reset-options "--initial_fuel 2 --max_fuel 2 --z3rlimit 20"
(* Repeating the same operation a number of times over a buffer ***************)
#reset-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** To be extracted as:
* for (int i = 0; i < n; ++i)
* f(b);
*)
inline_for_extraction
val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) )) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val repeat:
#a:Type0 ->
l: UInt32.t ->
f:(s:Seq.seq a{Seq.length s = UInt32.v l} ->
Tot (s':Seq.seq a{Seq.length s' = Seq.length s})) ->
b: buffer a{Buffer.length b = UInt32.v l} ->
max:UInt32.t ->
fc:(b:buffer a{length b = UInt32.v l} ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h0 _ h1 ->
live h0 b /\ live h1 b /\ modifies (loc_buffer b) h0 h1 /\ (
let b0 = as_seq h0 b in
let b1 = as_seq h1 b in
b1 == f b0)))) ->
Stack unit
(requires (fun h -> live h b ))
(ensures (fun h_1 r h_2 ->
modifies (loc_buffer b) h_1 h_2 /\ live h_1 b /\ live h_2 b /\ (
let s = as_seq h_1 b in
let s' = as_seq h_2 b in
s' == Spec.Loops.repeat (UInt32.v max) f s) )) | [] | C.Loops.repeat | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
l: FStar.UInt32.t ->
f:
(s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s = FStar.UInt32.v l}
-> s': FStar.Seq.Base.seq a {FStar.Seq.Base.length s' = FStar.Seq.Base.length s}) ->
b: LowStar.Buffer.buffer a {LowStar.Monotonic.Buffer.length b = FStar.UInt32.v l} ->
max: FStar.UInt32.t ->
fc:
(b: LowStar.Buffer.buffer a {LowStar.Monotonic.Buffer.length b = FStar.UInt32.v l}
-> FStar.HyperStack.ST.Stack Prims.unit)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 20,
"end_line": 410,
"start_col": 28,
"start_line": 396
} |
FStar.HyperStack.ST.Stack | val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) )) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2)) | val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
let map2 #a #b #c output in1 in2 l f = | true | null | false | let h0 = HST.get () in
let inv (h1: HS.mem) (i: nat) : Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\
i <= UInt32.v l /\
(forall (j: nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j) /\
(forall (j: nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v l})
: Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv h_2 (v i + 1))) =
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get () in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2)) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"FStar.Seq.Base.lemma_eq_intro",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Loops.seq_map2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowStar.BufferOps.op_Array_Assignment",
"LowStar.BufferOps.op_Array_Access",
"Prims.nat",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) )) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) )) | [] | C.Loops.map2 | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
output: LowStar.Buffer.buffer c ->
in1: LowStar.Buffer.buffer a {LowStar.Monotonic.Buffer.disjoint output in1} ->
in2: LowStar.Buffer.buffer b {LowStar.Monotonic.Buffer.disjoint output in2} ->
l:
FStar.UInt32.t
{ FStar.UInt32.v l = LowStar.Monotonic.Buffer.length output /\
FStar.UInt32.v l = LowStar.Monotonic.Buffer.length in1 /\
FStar.UInt32.v l = LowStar.Monotonic.Buffer.length in2 } ->
f: (_: a -> _: b -> c)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 84,
"end_line": 281,
"start_col": 38,
"start_line": 264
} |
FStar.HyperStack.ST.Stack | val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) )) | [
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "Buffer"
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "UInt64"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "UInt32"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowStar.BufferOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "C",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let in_place_map2 #a #b in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j)
/\ (forall (j:nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2)) | val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) ))
let in_place_map2 #a #b in1 in2 l f = | true | null | false | let h0 = HST.get () in
let inv (h1: HS.mem) (i: nat) : Type0 =
live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer in1) h0 h1 /\ i <= UInt32.v l /\
(forall (j: nat). (j >= i /\ j < UInt32.v l) ==> get h1 in1 j == get h0 in1 j) /\
(forall (j: nat). j < i ==> get h1 in1 j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i: UInt32.t{let open UInt32 in 0 <= v i /\ v i < v l})
: Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> let open UInt32 in inv h_2 (v i + 1))) =
let xi = in1.(i) in
let yi = in2.(i) in
in1.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get () in
Seq.lemma_eq_intro (as_seq h1 in1) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2)) | {
"checked_file": "C.Loops.fst.checked",
"dependencies": [
"Spec.Loops.fst.checked",
"prims.fst.checked",
"LowStar.BufferOps.fst.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "C.Loops.fst"
} | [] | [
"LowStar.Buffer.buffer",
"LowStar.Monotonic.Buffer.disjoint",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"FStar.Seq.Base.lemma_eq_intro",
"LowStar.Monotonic.Buffer.as_seq",
"Spec.Loops.seq_map2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"C.Loops.for",
"FStar.UInt32.__uint_to_t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.op_Addition",
"LowStar.BufferOps.op_Array_Assignment",
"LowStar.BufferOps.op_Array_Access",
"Prims.nat",
"LowStar.Monotonic.Buffer.live",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"LowStar.Monotonic.Buffer.get"
] | [] | (* This module exposes a series of combinators; they are modeled using
* higher-order functions and specifications, and extracted, using a
* meta-theoretic argument, to actual C loops. *)
module C.Loops
open FStar.HyperStack.ST
open LowStar.Buffer
open LowStar.BufferOps
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module UInt32 = FStar.UInt32
module UInt64 = FStar.UInt64
include Spec.Loops
module Buffer = LowStar.Buffer
#set-options "--initial_fuel 0 --max_fuel 0 --z3rlimit 20"
(** The functions in this module use the following convention:
* - the first arguments are buffers;
* - the destination buffer comes first, followed by the input buffer (as in
* C's memcpy)
* - each buffer is followed by its length; if several buffers share the same
* length, there is a single length argument after the buffers
* - the function-specific arguments come next (e.g. the number of times one
* may want to call the function in [repeat])
* - the second to last argument is the loop invariant (which may have
* dependencies on all the parameters before)
* - the last argument is the loop body (that will depend on the invariant, and
* possibly all the other parameters before. *)
(* Generic-purpose for-loop combinators ***************************************)
(* These combinators enjoy first-class support in KaRaMeL. (See [combinators] in
* src/Simplify.ml *)
(* Currently extracting as:
for (int i = <start>; i != <finish>; ++i)
<f> i;
*)
val for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec for start finish inv f =
if start = finish then
()
else begin
f start;
for (UInt32.(start +^ 1ul)) finish inv f
end
val for64:
start:UInt64.t ->
finish:UInt64.t{UInt64.v finish >= UInt64.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt64.t{UInt64.(v start <= v i /\ v i < v finish)} -> Stack unit
(requires (fun h -> inv h (UInt64.v i)))
(ensures (fun h_1 _ h_2 -> UInt64.(inv h_1 (v i) /\ inv h_2 (v i + 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt64.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt64.v finish)))
let rec for64 start finish inv f =
if start = finish then
()
else begin
f start;
for64 (UInt64.(start +^ 1UL)) finish inv f
end
(* To be extracted as:
for (int i = <start>; i != <finish>; --i)
<f> i;
*)
val reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_1 (v i) /\ inv h_2 (v i - 1)))) ) ->
Stack unit
(requires (fun h -> inv h (UInt32.v start)))
(ensures (fun _ _ h_2 -> inv h_2 (UInt32.v finish)))
let rec reverse_for start finish inv f =
if start = finish then
()
else begin
f start;
reverse_for (UInt32.(start -^ 1ul)) finish inv f
end
(* To be extracted as:
bool b = false;
int i = <start>;
for (; (!b) && (i != <end>); ++i) {
b = <f> i;
}
(i, b)
*)
val interruptible_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish >= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start <= v i /\ v i < v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i + 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start +^ 1ul) in
if f start
then (start', true)
else interruptible_for start' finish inv f
(* To be extracted as:
while (true) {
bool b = <f> i;
if (b) {
break;
}
}
*)
val do_while:
inv:(HS.mem -> bool -> GTot Type0) ->
f:(unit -> Stack bool
(requires (fun h -> inv h false))
(ensures (fun h_1 b h_2 -> inv h_1 false /\ inv h_2 b)) ) ->
Stack unit
(requires (fun h -> inv h false))
(ensures (fun _ _ h_2 -> inv h_2 true))
let rec do_while inv f =
if not (f ()) then
do_while inv f
(* Extracted as:
while (test ()) {
body ();
}
*)
val while:
#test_pre: (HS.mem -> GTot Type0) ->
#test_post: (bool -> HS.mem -> GTot Type0) ->
$test: (unit -> Stack bool
(requires (fun h -> test_pre h))
(ensures (fun h0 x h1 -> test_post x h1))) ->
body: (unit -> Stack unit
(requires (fun h -> test_post true h))
(ensures (fun h0 _ h1 -> test_pre h1))) ->
Stack unit
(requires (fun h -> test_pre h))
(ensures (fun h0 _ h1 -> test_post false h1))
let rec while #test_pre #test_post test body =
if test () then begin
body ();
while #test_pre #test_post test body
end
(* To be extracted as:
int i = <start>;
bool b = false;
for (; (!b) && (i != <end>); --i) {
b = <f> i;
}
// i and b must be in scope after the loop
*)
val interruptible_reverse_for:
start:UInt32.t ->
finish:UInt32.t{UInt32.v finish <= UInt32.v start} ->
inv:(HS.mem -> nat -> bool -> GTot Type0) ->
f:(i:UInt32.t{UInt32.(v start >= v i /\ v i > v finish)} -> Stack bool
(requires (fun h -> inv h (UInt32.v i) false))
(ensures (fun h_1 b h_2 -> inv h_1 (UInt32.v i) false /\ inv h_2 UInt32.(v i - 1) b)) ) ->
Stack (UInt32.t * bool)
(requires (fun h -> inv h (UInt32.v start) false))
(ensures (fun _ res h_2 -> let (i, b) = res in ((if b then True else i == finish) /\ inv h_2 (UInt32.v i) b)))
let rec interruptible_reverse_for start finish inv f =
if start = finish then
(finish, false)
else
let start' = UInt32.(start -^ 1ul) in
if f start
then (start', true)
else interruptible_reverse_for start' finish inv f
(* Non-primitive combinators that can be expressed in terms of the above ******)
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in[i]);
*)
inline_for_extraction
val map:
#a:Type0 -> #b:Type0 ->
output: buffer b ->
input: buffer a{disjoint input output} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length input } ->
f:(a -> Tot b) ->
Stack unit
(requires (fun h -> live h input /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 input /\ live h_1 input /\ live h_2 output
/\ live h_2 output
/\ (let s1 = as_seq h_1 input in
let s2 = as_seq h_2 output in
s2 == seq_map f s1) ))
inline_for_extraction
let map #a #b output input l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 input /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 input j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = input.(i) in
output.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map f (as_seq h0 input))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* out[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val map2:
#a:Type0 -> #b:Type0 -> #c:Type0 ->
output: buffer c ->
in1: buffer a{disjoint output in1} -> in2: buffer b{disjoint output in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length output /\ UInt32.v l = Buffer.length in1
/\ UInt32.v l = Buffer.length in2 } ->
f:(a -> b -> Tot c) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2 /\ live h output ))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer output) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2 /\ live h_2 output
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 output in
s == seq_map2 f s1 s2) ))
inline_for_extraction
let map2 #a #b #c output in1 in2 l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 output /\ live h1 in1 /\ live h1 in2 /\ modifies (loc_buffer output) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 output j == get h0 output j)
/\ (forall (j:nat). j < i ==> get h1 output j == f (get h0 in1 j) (get h0 in2 j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = in1.(i) in
let yi = in2.(i) in
output.(i) <- f xi yi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 output) (seq_map2 f (as_seq h0 in1) (as_seq h0 in2))
(** Extracts as:
* for (int i = 0; i < <l>; ++i)
* b[i] = <f>(b[i]);
*)
inline_for_extraction
val in_place_map:
#a:Type0 ->
b: buffer a ->
l: UInt32.t{ UInt32.v l = Buffer.length b } ->
f:(a -> Tot a) ->
Stack unit
(requires (fun h -> live h b))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer b) h_1 h_2 /\ live h_2 b /\ live h_1 b
/\ (let s1 = as_seq h_1 b in
let s2 = as_seq h_2 b in
s2 == seq_map f s1) ))
inline_for_extraction
let in_place_map #a b l f =
let h0 = HST.get() in
let inv (h1: HS.mem) (i: nat): Type0 =
live h1 b /\ modifies (loc_buffer b) h0 h1 /\ i <= UInt32.v l
/\ (forall (j:nat). (j >= i /\ j < UInt32.v l) ==> get h1 b j == get h0 b j)
/\ (forall (j:nat). j < i ==> get h1 b j == f (get h0 b j))
in
let f' (i:UInt32.t{ UInt32.( 0 <= v i /\ v i < v l ) }): Stack unit
(requires (fun h -> inv h (UInt32.v i)))
(ensures (fun h_1 _ h_2 -> UInt32.(inv h_2 (v i + 1))))
=
let xi = b.(i) in
b.(i) <- f xi
in
for 0ul l inv f';
let h1 = HST.get() in
Seq.lemma_eq_intro (as_seq h1 b) (seq_map f (as_seq h0 b))
(** Extracts as (destination buffer comes first):
* for (int i = 0; i < <l>; ++i)
* in1[i] = <f>(in1[i], in2[i]);
*)
inline_for_extraction
val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) )) | false | false | C.Loops.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val in_place_map2:
#a:Type0 -> #b:Type0 ->
in1: buffer a ->
in2: buffer b{disjoint in1 in2} ->
l: UInt32.t{ UInt32.v l = Buffer.length in1 /\ UInt32.v l = Buffer.length in2} ->
f:(a -> b -> Tot a) ->
Stack unit
(requires (fun h -> live h in1 /\ live h in2))
(ensures (fun h_1 r h_2 -> modifies (loc_buffer in1) h_1 h_2 /\ live h_2 in1 /\ live h_2 in2
/\ live h_1 in1 /\ live h_1 in2
/\ (let s1 = as_seq h_1 in1 in
let s2 = as_seq h_1 in2 in
let s = as_seq h_2 in1 in
s == seq_map2 f s1 s2) )) | [] | C.Loops.in_place_map2 | {
"file_name": "krmllib/C.Loops.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} |
in1: LowStar.Buffer.buffer a ->
in2: LowStar.Buffer.buffer b {LowStar.Monotonic.Buffer.disjoint in1 in2} ->
l:
FStar.UInt32.t
{ FStar.UInt32.v l = LowStar.Monotonic.Buffer.length in1 /\
FStar.UInt32.v l = LowStar.Monotonic.Buffer.length in2 } ->
f: (_: a -> _: b -> a)
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 81,
"end_line": 357,
"start_col": 37,
"start_line": 340
} |
FStar.HyperStack.ST.Stack | val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output | val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output = | true | null | false | keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Impl.SHA3.keccak",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | [] | Hacl.SHA3.shake128_hacl | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
outputByteLen: Lib.IntTypes.size_t ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 outputByteLen
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 73,
"end_line": 34,
"start_col": 2,
"start_line": 34
} |
FStar.HyperStack.ST.Stack | val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let shake256_hacl inputByteLen input outputByteLen output =
keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output | val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake256_hacl inputByteLen input outputByteLen output = | true | null | false | keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"Hacl.Impl.SHA3.keccak",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output
val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen)) | [] | Hacl.SHA3.shake256_hacl | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
outputByteLen: Lib.IntTypes.size_t ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 outputByteLen
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 73,
"end_line": 49,
"start_col": 2,
"start_line": 49
} |
FStar.HyperStack.ST.Stack | val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_224 inputByteLen input output =
keccak 1152ul 448ul inputByteLen input (byte 0x06) 28ul output | val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input))
let sha3_224 inputByteLen input output = | true | null | false | keccak 1152ul 448ul inputByteLen input (byte 0x06) 28ul output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.SHA3.keccak",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output
val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake256_hacl inputByteLen input outputByteLen output =
keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output
val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input)) | [] | Hacl.SHA3.sha3_224 | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 28ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 64,
"end_line": 63,
"start_col": 2,
"start_line": 63
} |
FStar.HyperStack.ST.Stack | val sha3_384:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 48ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_384 (v inputByteLen) (as_seq h0 input)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_384 inputByteLen input output =
keccak 832ul 768ul inputByteLen input (byte 0x06) 48ul output | val sha3_384:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 48ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_384 (v inputByteLen) (as_seq h0 input))
let sha3_384 inputByteLen input output = | true | null | false | keccak 832ul 768ul inputByteLen input (byte 0x06) 48ul output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.SHA3.keccak",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output
val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake256_hacl inputByteLen input outputByteLen output =
keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output
val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input))
let sha3_224 inputByteLen input output =
keccak 1152ul 448ul inputByteLen input (byte 0x06) 28ul output
val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input))
let sha3_256 inputByteLen input output =
keccak 1088ul 512ul inputByteLen input (byte 0x06) 32ul output
val sha3_384:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 48ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_384 (v inputByteLen) (as_seq h0 input)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_384:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 48ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_384 (v inputByteLen) (as_seq h0 input)) | [] | Hacl.SHA3.sha3_384 | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 48ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 63,
"end_line": 91,
"start_col": 2,
"start_line": 91
} |
FStar.HyperStack.ST.Stack | val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_256 inputByteLen input output =
keccak 1088ul 512ul inputByteLen input (byte 0x06) 32ul output | val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input))
let sha3_256 inputByteLen input output = | true | null | false | keccak 1088ul 512ul inputByteLen input (byte 0x06) 32ul output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.SHA3.keccak",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output
val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake256_hacl inputByteLen input outputByteLen output =
keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output
val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input))
let sha3_224 inputByteLen input output =
keccak 1152ul 448ul inputByteLen input (byte 0x06) 28ul output
val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input)) | [] | Hacl.SHA3.sha3_256 | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 64,
"end_line": 77,
"start_col": 2,
"start_line": 77
} |
FStar.HyperStack.ST.Stack | val sha3_512:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 64ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_512 (v inputByteLen) (as_seq h0 input)) | [
{
"abbrev": true,
"full_module": "Spec.SHA3",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.SHA3",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowStar.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let sha3_512 inputByteLen input output =
keccak 576ul 1024ul inputByteLen input (byte 0x06) 64ul output | val sha3_512:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 64ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_512 (v inputByteLen) (as_seq h0 input))
let sha3_512 inputByteLen input output = | true | null | false | keccak 576ul 1024ul inputByteLen input (byte 0x06) 64ul output | {
"checked_file": "Hacl.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.fst.checked",
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.SHA3.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.SHA3.fst"
} | [] | [
"Lib.IntTypes.size_t",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.SHA3.keccak",
"Lib.IntTypes.byte",
"Prims.unit"
] | [] | module Hacl.SHA3
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open LowStar.Buffer
open Lib.IntTypes
open Lib.Buffer
open Lib.ByteBuffer
open Hacl.Impl.SHA3
module ST = FStar.HyperStack.ST
module B = LowStar.Buffer
module S = Spec.SHA3
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0 --using_facts_from '* -FStar.Seq'"
val shake128_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake128 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake128_hacl inputByteLen input outputByteLen output =
keccak 1344ul 256ul inputByteLen input (byte 0x1F) outputByteLen output
val shake256_hacl:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> outputByteLen:size_t
-> output:lbuffer uint8 outputByteLen
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.shake256 (v inputByteLen) (as_seq h0 input) (v outputByteLen))
let shake256_hacl inputByteLen input outputByteLen output =
keccak 1088ul 512ul inputByteLen input (byte 0x1F) outputByteLen output
val sha3_224:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 28ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_224 (v inputByteLen) (as_seq h0 input))
let sha3_224 inputByteLen input output =
keccak 1152ul 448ul inputByteLen input (byte 0x06) 28ul output
val sha3_256:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_256 (v inputByteLen) (as_seq h0 input))
let sha3_256 inputByteLen input output =
keccak 1088ul 512ul inputByteLen input (byte 0x06) 32ul output
val sha3_384:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 48ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_384 (v inputByteLen) (as_seq h0 input))
let sha3_384 inputByteLen input output =
keccak 832ul 768ul inputByteLen input (byte 0x06) 48ul output
val sha3_512:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 64ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_512 (v inputByteLen) (as_seq h0 input)) | false | false | Hacl.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_512:
inputByteLen:size_t
-> input:lbuffer uint8 inputByteLen
-> output:lbuffer uint8 64ul
-> Stack unit
(requires fun h ->
live h input /\ live h output /\ disjoint input output)
(ensures fun h0 _ h1 ->
modifies (loc output) h0 h1 /\
as_seq h1 output ==
S.sha3_512 (v inputByteLen) (as_seq h0 input)) | [] | Hacl.SHA3.sha3_512 | {
"file_name": "code/sha3/Hacl.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Lib.IntTypes.size_t ->
input: Lib.Buffer.lbuffer Lib.IntTypes.uint8 inputByteLen ->
output: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 64,
"end_line": 105,
"start_col": 2,
"start_line": 105
} |
Prims.Tot | [
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let n = 64 | let n = | false | null | false | 64 | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val n : Prims.int | [] | FStar.Int64.n | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | Prims.int | {
"end_col": 17,
"end_line": 20,
"start_col": 15,
"start_line": 20
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Star_Hat = mul | let op_Star_Hat = | false | null | false | mul | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.mul"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Star_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Star_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 28,
"end_line": 123,
"start_col": 25,
"start_line": 123
} |
|
Prims.Tot | val eq (a b: t) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) | val eq (a b: t) : Tot bool
let eq (a b: t) : Tot bool = | false | null | false | eq #n (v a) (v b) | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"FStar.Int.eq",
"FStar.Int64.n",
"FStar.Int64.v",
"Prims.bool"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c)) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eq (a b: t) : Tot bool | [] | FStar.Int64.eq | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 49,
"end_line": 114,
"start_col": 32,
"start_line": 114
} |
Prims.Tot | val lte (a b: t) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) | val lte (a b: t) : Tot bool
let lte (a b: t) : Tot bool = | false | null | false | lte #n (v a) (v b) | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"FStar.Int.lte",
"FStar.Int64.n",
"FStar.Int64.v",
"Prims.bool"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lte (a b: t) : Tot bool | [] | FStar.Int64.lte | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 51,
"end_line": 118,
"start_col": 33,
"start_line": 118
} |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Slash_Hat = div | let op_Slash_Hat = | false | null | false | div | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.div"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Slash_Hat : a: FStar.Int64.t -> b: FStar.Int64.t{FStar.Int64.v b <> 0} -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Slash_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t{FStar.Int64.v b <> 0} -> Prims.Pure FStar.Int64.t | {
"end_col": 29,
"end_line": 124,
"start_col": 26,
"start_line": 124
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Subtraction_Hat = sub | let op_Subtraction_Hat = | false | null | false | sub | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.sub"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *) | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Subtraction_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Subtraction_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 35,
"end_line": 122,
"start_col": 32,
"start_line": 122
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Plus_Hat = add | let op_Plus_Hat = | false | null | false | add | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.add"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b) | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Plus_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Plus_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 28,
"end_line": 121,
"start_col": 25,
"start_line": 121
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Amp_Hat = logand | let op_Amp_Hat = | false | null | false | logand | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.logand"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Amp_Hat : x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Amp_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 30,
"end_line": 127,
"start_col": 24,
"start_line": 127
} |
|
Prims.Tot | val lt (a b: t) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b) | val lt (a b: t) : Tot bool
let lt (a b: t) : Tot bool = | false | null | false | lt #n (v a) (v b) | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"FStar.Int.lt",
"FStar.Int64.n",
"FStar.Int64.v",
"Prims.bool"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lt (a b: t) : Tot bool | [] | FStar.Int64.lt | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 49,
"end_line": 117,
"start_col": 32,
"start_line": 117
} |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Percent_Hat = rem | let op_Percent_Hat = | false | null | false | rem | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.rem"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Percent_Hat : a: FStar.Int64.t -> b: FStar.Int64.t{FStar.Int64.v b <> 0} -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Percent_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t{FStar.Int64.v b <> 0} -> Prims.Pure FStar.Int64.t | {
"end_col": 31,
"end_line": 125,
"start_col": 28,
"start_line": 125
} |
|
Prims.Tot | val gte (a b: t) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b) | val gte (a b: t) : Tot bool
let gte (a b: t) : Tot bool = | false | null | false | gte #n (v a) (v b) | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"FStar.Int.gte",
"FStar.Int64.n",
"FStar.Int64.v",
"Prims.bool"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gte (a b: t) : Tot bool | [] | FStar.Int64.gte | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 51,
"end_line": 116,
"start_col": 33,
"start_line": 116
} |
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Bar_Hat = logor | let op_Bar_Hat = | false | null | false | logor | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.logor"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Bar_Hat : x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Bar_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 29,
"end_line": 128,
"start_col": 24,
"start_line": 128
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Hat_Hat = logxor | let op_Hat_Hat = | false | null | false | logxor | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.logxor"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Hat_Hat : x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Hat_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: FStar.Int64.t -> y: FStar.Int64.t -> Prims.Pure FStar.Int64.t | {
"end_col": 30,
"end_line": 126,
"start_col": 24,
"start_line": 126
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Greater_Greater_Hat = shift_right | let op_Greater_Greater_Hat = | false | null | false | shift_right | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.shift_right"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Greater_Greater_Hat : a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Greater_Greater_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | {
"end_col": 47,
"end_line": 130,
"start_col": 36,
"start_line": 130
} |
|
Prims.Tot | val gt (a b: t) : Tot bool | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b) | val gt (a b: t) : Tot bool
let gt (a b: t) : Tot bool = | false | null | false | gt #n (v a) (v b) | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"FStar.Int.gt",
"FStar.Int64.n",
"FStar.Int64.v",
"Prims.bool"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *) | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gt (a b: t) : Tot bool | [] | FStar.Int64.gt | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 49,
"end_line": 115,
"start_col": 32,
"start_line": 115
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Equals_Hat = eq | let op_Equals_Hat = | false | null | false | eq | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.eq"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Equals_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | [] | FStar.Int64.op_Equals_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 29,
"end_line": 132,
"start_col": 27,
"start_line": 132
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Less_Less_Hat = shift_left | let op_Less_Less_Hat = | false | null | false | shift_left | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.shift_left"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Less_Less_Hat : a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Less_Less_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | {
"end_col": 40,
"end_line": 129,
"start_col": 30,
"start_line": 129
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Less_Equals_Hat = lte | let op_Less_Equals_Hat = | false | null | false | lte | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.lte"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right
unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right
unfold let op_Equals_Hat = eq
unfold let op_Greater_Hat = gt
unfold let op_Greater_Equals_Hat = gte | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Less_Equals_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | [] | FStar.Int64.op_Less_Equals_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 35,
"end_line": 136,
"start_col": 32,
"start_line": 136
} |
|
Prims.Pure | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Greater_Greater_Greater_Hat = shift_arithmetic_right | let op_Greater_Greater_Greater_Hat = | false | null | false | shift_arithmetic_right | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [] | [
"FStar.Int64.shift_arithmetic_right"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Greater_Greater_Greater_Hat : a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | [] | FStar.Int64.op_Greater_Greater_Greater_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> s: FStar.UInt32.t -> Prims.Pure FStar.Int64.t | {
"end_col": 66,
"end_line": 131,
"start_col": 44,
"start_line": 131
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Greater_Hat = gt | let op_Greater_Hat = | false | null | false | gt | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.gt"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right
unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Greater_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | [] | FStar.Int64.op_Greater_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 30,
"end_line": 133,
"start_col": 28,
"start_line": 133
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Less_Hat = lt | let op_Less_Hat = | false | null | false | lt | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.lt"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right
unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right
unfold let op_Equals_Hat = eq
unfold let op_Greater_Hat = gt | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Less_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | [] | FStar.Int64.op_Less_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 27,
"end_line": 135,
"start_col": 25,
"start_line": 135
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let op_Greater_Equals_Hat = gte | let op_Greater_Equals_Hat = | false | null | false | gte | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.gte"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right
unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right
unfold let op_Equals_Hat = eq | false | true | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Greater_Equals_Hat : a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | [] | FStar.Int64.op_Greater_Equals_Hat | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t -> b: FStar.Int64.t -> Prims.bool | {
"end_col": 38,
"end_line": 134,
"start_col": 35,
"start_line": 134
} |
|
Prims.Tot | val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)}) | [
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Int",
"short_module": null
},
{
"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",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ct_abs (a:t{min_int n < v a}) : Tot (b:t{v b = abs (v a)}) =
let mask = a >>>^ UInt32.uint_to_t (n - 1) in
if 0 <= v a then
begin
sign_bit_positive (v a);
nth_lemma (v mask) (FStar.Int.zero _);
logxor_lemma_1 (v a)
end
else
begin
sign_bit_negative (v a);
nth_lemma (v mask) (ones _);
logxor_lemma_2 (v a);
lognot_negative (v a);
UInt.lemma_lognot_value #n (to_uint (v a))
end;
(a ^^ mask) -^ mask | val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)})
let ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)}) = | false | null | false | let mask = a >>>^ UInt32.uint_to_t (n - 1) in
if 0 <= v a
then
(sign_bit_positive (v a);
nth_lemma (v mask) (FStar.Int.zero _);
logxor_lemma_1 (v a))
else
(sign_bit_negative (v a);
nth_lemma (v mask) (ones _);
logxor_lemma_2 (v a);
lognot_negative (v a);
UInt.lemma_lognot_value #n (to_uint (v a)));
(a ^^ mask) -^ mask | {
"checked_file": "FStar.Int64.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.UInt.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Int.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Int64.fsti"
} | [
"total"
] | [
"FStar.Int64.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Int.min_int",
"FStar.Int64.n",
"FStar.Int64.v",
"FStar.Int64.op_Subtraction_Hat",
"FStar.Int64.op_Hat_Hat",
"Prims.unit",
"Prims.op_LessThanOrEqual",
"FStar.Int.logxor_lemma_1",
"FStar.Int.nth_lemma",
"FStar.Int.zero",
"FStar.Int.sign_bit_positive",
"Prims.bool",
"FStar.UInt.lemma_lognot_value",
"FStar.Int.to_uint",
"FStar.Int.lognot_negative",
"FStar.Int.logxor_lemma_2",
"FStar.Int.ones",
"FStar.Int.sign_bit_negative",
"FStar.Int64.op_Greater_Greater_Greater_Hat",
"FStar.UInt32.uint_to_t",
"Prims.op_Subtraction",
"Prims.op_Equality",
"Prims.int",
"Prims.abs"
] | [] | (*
Copyright 2008-2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Int64
(**** THIS MODULE IS GENERATED AUTOMATICALLY USING [mk_int.sh], DO NOT EDIT DIRECTLY ****)
unfold let n = 64
open FStar.Int
open FStar.Mul
#set-options "--max_fuel 0 --max_ifuel 0"
(* NOTE: anything that you fix/update here should be reflected in [FStar.UIntN.fstp], which is mostly
* a copy-paste of this module. *)
new val t : eqtype
val v (x:t) : Tot (int_t n)
val int_to_t: x:int_t n -> Pure t
(requires True)
(ensures (fun y -> v y = x))
val uv_inv (x : t) : Lemma
(ensures (int_to_t (v x) == x))
[SMTPat (v x)]
val vu_inv (x : int_t n) : Lemma
(ensures (v (int_to_t x) == x))
[SMTPat (int_to_t x)]
val v_inj (x1 x2: t): Lemma
(requires (v x1 == v x2))
(ensures (x1 == x2))
val zero : x:t{v x = 0}
val one : x:t{v x = 1}
val add (a:t) (b:t) : Pure t
(requires (size (v a + v b) n))
(ensures (fun c -> v a + v b = v c))
(* Subtraction primitives *)
val sub (a:t) (b:t) : Pure t
(requires (size (v a - v b) n))
(ensures (fun c -> v a - v b = v c))
(* Multiplication primitives *)
val mul (a:t) (b:t) : Pure t
(requires (size (v a * v b) n))
(ensures (fun c -> v a * v b = v c))
(* Division primitives *)
val div (a:t) (b:t{v b <> 0}) : Pure t
// division overflows on INT_MIN / -1
(requires (size (v a / v b) n))
(ensures (fun c -> v a / v b = v c))
(* Modulo primitives *)
(* If a/b is not representable the result of a%b is undefind *)
val rem (a:t) (b:t{v b <> 0}) : Pure t
(requires (size (v a / v b) n))
(ensures (fun c -> FStar.Int.mod (v a) (v b) = v c))
(* Bitwise operators *)
val logand (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logand` v y = v z))
val logxor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logxor` v y == v z))
val logor (x:t) (y:t) : Pure t
(requires True)
(ensures (fun z -> v x `logor` v y == v z))
val lognot (x:t) : Pure t
(requires True)
(ensures (fun z -> lognot (v x) == v z))
(* Shift operators *)
(** If a is negative the result is implementation-defined *)
val shift_right (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_right (v a) (UInt32.v s) = v c))
(** If a is negative or a * pow2 s is not representable the result is undefined *)
val shift_left (a:t) (s:UInt32.t) : Pure t
(requires (0 <= v a /\ v a * pow2 (UInt32.v s) <= max_int n /\ UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_left (v a) (UInt32.v s) = v c))
val shift_arithmetic_right (a:t) (s:UInt32.t) : Pure t
(requires (UInt32.v s < n))
(ensures (fun c -> FStar.Int.shift_arithmetic_right (v a) (UInt32.v s) = v c))
(* Comparison operators *)
let eq (a:t) (b:t) : Tot bool = eq #n (v a) (v b)
let gt (a:t) (b:t) : Tot bool = gt #n (v a) (v b)
let gte (a:t) (b:t) : Tot bool = gte #n (v a) (v b)
let lt (a:t) (b:t) : Tot bool = lt #n (v a) (v b)
let lte (a:t) (b:t) : Tot bool = lte #n (v a) (v b)
(* Infix notations *)
unfold let op_Plus_Hat = add
unfold let op_Subtraction_Hat = sub
unfold let op_Star_Hat = mul
unfold let op_Slash_Hat = div
unfold let op_Percent_Hat = rem
unfold let op_Hat_Hat = logxor
unfold let op_Amp_Hat = logand
unfold let op_Bar_Hat = logor
unfold let op_Less_Less_Hat = shift_left
unfold let op_Greater_Greater_Hat = shift_right
unfold let op_Greater_Greater_Greater_Hat = shift_arithmetic_right
unfold let op_Equals_Hat = eq
unfold let op_Greater_Hat = gt
unfold let op_Greater_Equals_Hat = gte
unfold let op_Less_Hat = lt
unfold let op_Less_Equals_Hat = lte | false | false | FStar.Int64.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ct_abs (a: t{min_int n < v a}) : Tot (b: t{v b = abs (v a)}) | [] | FStar.Int64.ct_abs | {
"file_name": "ulib/FStar.Int64.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | a: FStar.Int64.t{FStar.Int.min_int FStar.Int64.n < FStar.Int64.v a}
-> b: FStar.Int64.t{FStar.Int64.v b = Prims.abs (FStar.Int64.v a)} | {
"end_col": 21,
"end_line": 155,
"start_col": 64,
"start_line": 139
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let top = (b:Type & b) | let top = | false | null | false | (b: Type & b) | {
"checked_file": "FStar.WellFounded.Util.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFounded.Util.fsti"
} | [
"total"
] | [
"Prims.dtuple2"
] | [] | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Authors: N. Swamy
*)
module FStar.WellFounded.Util
open FStar.WellFounded
(** Provides some utilities related to well-founded relations *)
(* 1. Given a well-founded relation `r:binrel a`
turn it into a well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is useful when writing type-polymorphic recursive functions
whose termination depends on some custom well-founded order
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly2
*) | false | true | FStar.WellFounded.Util.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val top : Type | [] | FStar.WellFounded.Util.top | {
"file_name": "ulib/FStar.WellFounded.Util.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | Type | {
"end_col": 22,
"end_line": 34,
"start_col": 10,
"start_line": 34
} |
|
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let squash_binrel (#a:Type) (r:binrel u#a u#r a) (x y:a) = squash (r x y) | let squash_binrel (#a: Type) (r: binrel u#a u#r a) (x y: a) = | false | null | false | squash (r x y) | {
"checked_file": "FStar.WellFounded.Util.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFounded.Util.fsti"
} | [
"total"
] | [
"FStar.WellFounded.binrel",
"Prims.squash"
] | [] | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Authors: N. Swamy
*)
module FStar.WellFounded.Util
open FStar.WellFounded
(** Provides some utilities related to well-founded relations *)
(* 1. Given a well-founded relation `r:binrel a`
turn it into a well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is useful when writing type-polymorphic recursive functions
whose termination depends on some custom well-founded order
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly2
*)
let top = (b:Type & b)
let lift_binrel (#a:Type)
(r:binrel a)
: binrel top
= fun (t0 t1:top) ->
(_:(dfst t0==a /\ dfst t1==a) & r (dsnd t0) (dsnd t1))
val intro_lift_binrel (#a:Type) (r:binrel a) (y:a) (x:a)
: Lemma
(requires r y x)
(ensures lift_binrel r (| a, y |) (| a, x |))
val elim_lift_binrel (#a:Type) (r:binrel a) (y:top) (x:a)
: Lemma
(requires lift_binrel r y (| a, x |))
(ensures dfst y == a /\ r (dsnd y) x)
val lower_binrel (#a:Type)
(#r:binrel a)
(x y:top)
(p:lift_binrel r x y)
: r (dsnd x) (dsnd y)
val lift_binrel_well_founded (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded r)
: well_founded (lift_binrel r)
let lift_binrel_as_well_founded_relation (#a:Type u#a) (#r:binrel u#a u#r a) (wf_r:well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a)
= as_well_founded #top #(lift_binrel r) (lift_binrel_well_founded wf_r)
(* 2. Given a well-founded relation `r:binrel a`
turn it into a *squashed* well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is very similar to 1, but uses squashed types,
which leads to slightly better SMT automation at use sites.
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly
*)
let lift_binrel_squashed (#a:Type u#a)
(r:binrel u#a u#r a)
: binrel top
= fun (t0 t1:top) ->
(dfst t0==a /\ dfst t1==a /\ squash (r (dsnd t0) (dsnd t1)))
val lower_binrel_squashed (#a:Type u#a)
(#r:binrel u#a u#r a)
(x y:top u#a)
(p:lift_binrel_squashed r x y)
: squash (r (dsnd x) (dsnd y)) | false | false | FStar.WellFounded.Util.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val squash_binrel : r: FStar.WellFounded.binrel a -> x: a -> y: a -> Type0 | [] | FStar.WellFounded.Util.squash_binrel | {
"file_name": "ulib/FStar.WellFounded.Util.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | r: FStar.WellFounded.binrel a -> x: a -> y: a -> Type0 | {
"end_col": 73,
"end_line": 93,
"start_col": 59,
"start_line": 93
} |
|
Prims.Tot | val lift_binrel_squashed_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded (squash_binrel r))
: well_founded_relation u#(a + 1) u#0 top | [
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lift_binrel_squashed_as_well_founded_relation (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded (squash_binrel r))
: well_founded_relation u#(a + 1) u#0 top
= as_well_founded #top #(lift_binrel_squashed r) (lift_binrel_squashed_well_founded wf_r) | val lift_binrel_squashed_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded (squash_binrel r))
: well_founded_relation u#(a + 1) u#0 top
let lift_binrel_squashed_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded (squash_binrel r))
: well_founded_relation u#(a + 1) u#0 top = | false | null | false | as_well_founded #top #(lift_binrel_squashed r) (lift_binrel_squashed_well_founded wf_r) | {
"checked_file": "FStar.WellFounded.Util.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFounded.Util.fsti"
} | [
"total"
] | [
"FStar.WellFounded.binrel",
"FStar.WellFounded.well_founded",
"FStar.WellFounded.Util.squash_binrel",
"FStar.WellFounded.as_well_founded",
"FStar.WellFounded.Util.top",
"FStar.WellFounded.Util.lift_binrel_squashed",
"FStar.WellFounded.Util.lift_binrel_squashed_well_founded",
"FStar.WellFounded.well_founded_relation"
] | [] | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Authors: N. Swamy
*)
module FStar.WellFounded.Util
open FStar.WellFounded
(** Provides some utilities related to well-founded relations *)
(* 1. Given a well-founded relation `r:binrel a`
turn it into a well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is useful when writing type-polymorphic recursive functions
whose termination depends on some custom well-founded order
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly2
*)
let top = (b:Type & b)
let lift_binrel (#a:Type)
(r:binrel a)
: binrel top
= fun (t0 t1:top) ->
(_:(dfst t0==a /\ dfst t1==a) & r (dsnd t0) (dsnd t1))
val intro_lift_binrel (#a:Type) (r:binrel a) (y:a) (x:a)
: Lemma
(requires r y x)
(ensures lift_binrel r (| a, y |) (| a, x |))
val elim_lift_binrel (#a:Type) (r:binrel a) (y:top) (x:a)
: Lemma
(requires lift_binrel r y (| a, x |))
(ensures dfst y == a /\ r (dsnd y) x)
val lower_binrel (#a:Type)
(#r:binrel a)
(x y:top)
(p:lift_binrel r x y)
: r (dsnd x) (dsnd y)
val lift_binrel_well_founded (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded r)
: well_founded (lift_binrel r)
let lift_binrel_as_well_founded_relation (#a:Type u#a) (#r:binrel u#a u#r a) (wf_r:well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a)
= as_well_founded #top #(lift_binrel r) (lift_binrel_well_founded wf_r)
(* 2. Given a well-founded relation `r:binrel a`
turn it into a *squashed* well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is very similar to 1, but uses squashed types,
which leads to slightly better SMT automation at use sites.
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly
*)
let lift_binrel_squashed (#a:Type u#a)
(r:binrel u#a u#r a)
: binrel top
= fun (t0 t1:top) ->
(dfst t0==a /\ dfst t1==a /\ squash (r (dsnd t0) (dsnd t1)))
val lower_binrel_squashed (#a:Type u#a)
(#r:binrel u#a u#r a)
(x y:top u#a)
(p:lift_binrel_squashed r x y)
: squash (r (dsnd x) (dsnd y))
let squash_binrel (#a:Type) (r:binrel u#a u#r a) (x y:a) = squash (r x y)
val lift_binrel_squashed_well_founded (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded (squash_binrel r))
: well_founded (lift_binrel_squashed r)
let lift_binrel_squashed_as_well_founded_relation (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded (squash_binrel r)) | false | false | FStar.WellFounded.Util.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_binrel_squashed_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded (squash_binrel r))
: well_founded_relation u#(a + 1) u#0 top | [] | FStar.WellFounded.Util.lift_binrel_squashed_as_well_founded_relation | {
"file_name": "ulib/FStar.WellFounded.Util.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | wf_r: FStar.WellFounded.well_founded (FStar.WellFounded.Util.squash_binrel r)
-> FStar.WellFounded.well_founded_relation FStar.WellFounded.Util.top | {
"end_col": 91,
"end_line": 105,
"start_col": 4,
"start_line": 105
} |
Prims.Tot | val lift_binrel_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a) | [
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.WellFounded",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lift_binrel_as_well_founded_relation (#a:Type u#a) (#r:binrel u#a u#r a) (wf_r:well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a)
= as_well_founded #top #(lift_binrel r) (lift_binrel_well_founded wf_r) | val lift_binrel_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a)
let lift_binrel_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a) = | false | null | false | as_well_founded #top #(lift_binrel r) (lift_binrel_well_founded wf_r) | {
"checked_file": "FStar.WellFounded.Util.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.WellFounded.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.WellFounded.Util.fsti"
} | [
"total"
] | [
"FStar.WellFounded.binrel",
"FStar.WellFounded.well_founded",
"FStar.WellFounded.as_well_founded",
"FStar.WellFounded.Util.top",
"FStar.WellFounded.Util.lift_binrel",
"FStar.WellFounded.Util.lift_binrel_well_founded",
"FStar.WellFounded.well_founded_relation"
] | [] | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Authors: N. Swamy
*)
module FStar.WellFounded.Util
open FStar.WellFounded
(** Provides some utilities related to well-founded relations *)
(* 1. Given a well-founded relation `r:binrel a`
turn it into a well-founded relation on `binrel top`,
by construction a relation that only relates `top` elements
in `a` by `r`
This is useful when writing type-polymorphic recursive functions
whose termination depends on some custom well-founded order
See tests/micro-benchmarks/TestWellFoundedRecursion.rel_poly2
*)
let top = (b:Type & b)
let lift_binrel (#a:Type)
(r:binrel a)
: binrel top
= fun (t0 t1:top) ->
(_:(dfst t0==a /\ dfst t1==a) & r (dsnd t0) (dsnd t1))
val intro_lift_binrel (#a:Type) (r:binrel a) (y:a) (x:a)
: Lemma
(requires r y x)
(ensures lift_binrel r (| a, y |) (| a, x |))
val elim_lift_binrel (#a:Type) (r:binrel a) (y:top) (x:a)
: Lemma
(requires lift_binrel r y (| a, x |))
(ensures dfst y == a /\ r (dsnd y) x)
val lower_binrel (#a:Type)
(#r:binrel a)
(x y:top)
(p:lift_binrel r x y)
: r (dsnd x) (dsnd y)
val lift_binrel_well_founded (#a:Type u#a)
(#r:binrel u#a u#r a)
(wf_r:well_founded r)
: well_founded (lift_binrel r)
let lift_binrel_as_well_founded_relation (#a:Type u#a) (#r:binrel u#a u#r a) (wf_r:well_founded r) | false | false | FStar.WellFounded.Util.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lift_binrel_as_well_founded_relation
(#a: Type u#a)
(#r: binrel u#a u#r a)
(wf_r: well_founded r)
: well_founded_relation u#(a + 1) u#r (top u#a) | [] | FStar.WellFounded.Util.lift_binrel_as_well_founded_relation | {
"file_name": "ulib/FStar.WellFounded.Util.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | wf_r: FStar.WellFounded.well_founded r
-> FStar.WellFounded.well_founded_relation FStar.WellFounded.Util.top | {
"end_col": 73,
"end_line": 66,
"start_col": 4,
"start_line": 66
} |
Prims.Tot | val va_wp_VHigh64ToLow
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (()))) | val va_wp_VHigh64ToLow
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VHigh64ToLow
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (- 64)
) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VHigh64ToLow
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_VHigh64ToLow | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 25,
"end_line": 135,
"start_col": 2,
"start_line": 129
} |
Prims.Tot | val va_wp_PolyAnd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (()))) | val va_wp_PolyAnd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_PolyAnd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let a2:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let a2:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.sse_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2.poly_and",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_PolyAnd (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_PolyAnd | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 21,
"end_line": 95,
"start_col": 2,
"start_line": 87
} |
Prims.Tot | val va_wp_VPolyAdd
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (()))) | val va_wp_VPolyAdd
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPolyAdd
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\
va_get_ok va_s0 /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let a2:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let a2:Vale.Math.Poly2_s.poly =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Vale.X64.Decls.va_is_src_opr128",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_opr128",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2_s.add",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPolyAdd
(dst src1: va_operand_xmm)
(src2: va_operand_opr128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_VPolyAdd | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 21,
"end_line": 52,
"start_col": 2,
"start_line": 44
} |
Prims.Tot | val va_wp_VSwap (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) ==> va_k
va_sM (()))) | val va_wp_VSwap (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VSwap (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2.swap",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (())))
val va_wpProof_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VLow64ToHigh dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VLow64ToHigh dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VLow64ToHigh dst src)) =
(va_QProc (va_code_VLow64ToHigh dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VLow64ToHigh dst
src) (va_wpProof_VLow64ToHigh dst src))
//--
//-- VSwap
val va_code_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VSwap : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VSwap dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VSwap (dst src: va_operand_xmm) (va_s0: va_state) (va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_VSwap | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 16,
"end_line": 214,
"start_col": 2,
"start_line": 208
} |
Prims.Tot | val va_wp_VLow64ToHigh
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (()))) | val va_wp_VLow64ToHigh
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VLow64ToHigh
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) ==
Vale.Math.Poly2_s.shift (Vale.Math.Poly2.mask a 64) 64) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2_s.shift",
"Vale.Math.Poly2.mask",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VLow64ToHigh
(dst src: va_operand_xmm)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_VLow64ToHigh | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src: Vale.X64.Decls.va_operand_xmm ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 57,
"end_line": 175,
"start_col": 2,
"start_line": 169
} |
Prims.Tot | val va_wp_VPolyMul
(dst src1 src2: va_operand_xmm)
(src1Hi src2Hi: bool)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_wp_VPolyMul (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (src1Hi:bool)
(src2Hi:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src2) in pclmulqdq_enabled /\ avx_enabled) /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32
(va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.mul (va_if src1Hi (fun _ ->
Vale.Math.Poly2_s.shift a1 (-64)) (fun _ -> Vale.Math.Poly2.mask a1 64)) (va_if src2Hi (fun _
-> Vale.Math.Poly2_s.shift a2 (-64)) (fun _ -> Vale.Math.Poly2.mask a2 64))) ==> va_k va_sM
(()))) | val va_wp_VPolyMul
(dst src1 src2: va_operand_xmm)
(src1Hi src2Hi: bool)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_VPolyMul
(dst src1 src2: va_operand_xmm)
(src1Hi src2Hi: bool)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | false | null | false | (va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok va_s0 /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let a2:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in
pclmulqdq_enabled /\ avx_enabled) /\
(forall (va_x_dst: va_value_xmm) (va_x_efl: Vale.X64.Flags.t).
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in
va_get_ok va_sM /\
(let a1:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let a2:Vale.Math.Poly2_s.poly = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) ==
Vale.Math.Poly2_s.mul (va_if src1Hi
(fun _ -> Vale.Math.Poly2_s.shift a1 (- 64))
(fun _ -> Vale.Math.Poly2.mask a1 64))
(va_if src2Hi
(fun _ -> Vale.Math.Poly2_s.shift a2 (- 64))
(fun _ -> Vale.Math.Poly2.mask a2 64))) ==>
va_k va_sM (()))) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.bool",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Vale.X64.Decls.va_is_dst_xmm",
"Vale.X64.Decls.va_is_src_xmm",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.CPU_Features_s.pclmulqdq_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.Math.Poly2_s.poly",
"Vale.Math.Poly2.Bits_s.of_quad32",
"Vale.X64.Decls.va_eval_xmm",
"Prims.l_Forall",
"Vale.X64.Decls.va_value_xmm",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Prims.eq2",
"Vale.Math.Poly2_s.mul",
"Vale.X64.Decls.va_if",
"Vale.Math.Poly2_s.shift",
"Prims.op_Minus",
"Prims.l_not",
"Vale.Math.Poly2.mask",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_operand_xmm"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (())))
val va_wpProof_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VLow64ToHigh dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VLow64ToHigh dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VLow64ToHigh dst src)) =
(va_QProc (va_code_VLow64ToHigh dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VLow64ToHigh dst
src) (va_wpProof_VLow64ToHigh dst src))
//--
//-- VSwap
val va_code_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VSwap : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VSwap dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) ==> va_k
va_sM (())))
val va_wpProof_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VSwap dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VSwap dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_VSwap
dst src)) =
(va_QProc (va_code_VSwap dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VSwap dst src)
(va_wpProof_VSwap dst src))
//--
//-- VPolyMul
val va_code_VPolyMul : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
src1Hi:bool -> src2Hi:bool -> Tot va_code
val va_codegen_success_VPolyMul : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> src1Hi:bool -> src2Hi:bool -> Tot va_pbool
val va_lemma_VPolyMul : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_xmm -> src1Hi:bool -> src2Hi:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyMul dst src1 src2 src1Hi src2Hi) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src2) in pclmulqdq_enabled /\ avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.mul (if src1Hi
then Vale.Math.Poly2_s.shift a1 (-64) else Vale.Math.Poly2.mask a1 64) (if src2Hi then
Vale.Math.Poly2_s.shift a2 (-64) else Vale.Math.Poly2.mask a2 64)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VPolyMul (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (src1Hi:bool) | false | true | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_wp_VPolyMul
(dst src1 src2: va_operand_xmm)
(src1Hi src2Hi: bool)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.PolyOps.va_wp_VPolyMul | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
src1Hi: Prims.bool ->
src2Hi: Prims.bool ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | {
"end_col": 10,
"end_line": 265,
"start_col": 2,
"start_line": 254
} |
Prims.Tot | val va_quick_VPolyAdd (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPolyAdd dst src1 src2)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2)) | val va_quick_VPolyAdd (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPolyAdd dst src1 src2))
let va_quick_VPolyAdd (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPolyAdd dst src1 src2)) = | false | null | false | (va_QProc (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPolyAdd dst src1 src2)
(va_wpProof_VPolyAdd dst src1 src2)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_operand_opr128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_VPolyAdd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_VPolyAdd",
"Vale.AES.X64.PolyOps.va_wpProof_VPolyAdd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) : | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_VPolyAdd (dst src1: va_operand_xmm) (src2: va_operand_opr128)
: (va_quickCode unit (va_code_VPolyAdd dst src1 src2)) | [] | Vale.AES.X64.PolyOps.va_quick_VPolyAdd | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_opr128
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.PolyOps.va_code_VPolyAdd dst src1 src2) | {
"end_col": 51,
"end_line": 64,
"start_col": 2,
"start_line": 63
} |
Prims.Tot | val va_quick_PolyAnd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_PolyAnd dst src)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src)) | val va_quick_PolyAnd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_PolyAnd dst src))
let va_quick_PolyAnd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_PolyAnd dst src)) = | false | null | false | (va_QProc (va_code_PolyAnd dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_PolyAnd",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_PolyAnd",
"Vale.AES.X64.PolyOps.va_wpProof_PolyAnd",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_PolyAnd (dst src: va_operand_xmm) : (va_quickCode unit (va_code_PolyAnd dst src)) | [] | Vale.AES.X64.PolyOps.va_quick_PolyAnd | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.AES.X64.PolyOps.va_code_PolyAnd dst src) | {
"end_col": 33,
"end_line": 107,
"start_col": 2,
"start_line": 106
} |
Prims.Tot | val va_quick_VHigh64ToLow (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VHigh64ToLow dst src)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src)) | val va_quick_VHigh64ToLow (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VHigh64ToLow dst src))
let va_quick_VHigh64ToLow (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VHigh64ToLow dst src)) = | false | null | false | (va_QProc (va_code_VHigh64ToLow dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VHigh64ToLow dst src)
(va_wpProof_VHigh64ToLow dst src)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_VHigh64ToLow",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_VHigh64ToLow",
"Vale.AES.X64.PolyOps.va_wpProof_VHigh64ToLow",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_VHigh64ToLow (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VHigh64ToLow dst src)) | [] | Vale.AES.X64.PolyOps.va_quick_VHigh64ToLow | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.AES.X64.PolyOps.va_code_VHigh64ToLow dst src) | {
"end_col": 43,
"end_line": 147,
"start_col": 2,
"start_line": 146
} |
Prims.Tot | val va_quick_VLow64ToHigh (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VLow64ToHigh dst src)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VLow64ToHigh dst src)) =
(va_QProc (va_code_VLow64ToHigh dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VLow64ToHigh dst
src) (va_wpProof_VLow64ToHigh dst src)) | val va_quick_VLow64ToHigh (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VLow64ToHigh dst src))
let va_quick_VLow64ToHigh (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VLow64ToHigh dst src)) = | false | null | false | (va_QProc (va_code_VLow64ToHigh dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VLow64ToHigh dst src)
(va_wpProof_VLow64ToHigh dst src)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_VLow64ToHigh",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_VLow64ToHigh",
"Vale.AES.X64.PolyOps.va_wpProof_VLow64ToHigh",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (())))
val va_wpProof_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VLow64ToHigh dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VLow64ToHigh dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_VLow64ToHigh (dst src: va_operand_xmm)
: (va_quickCode unit (va_code_VLow64ToHigh dst src)) | [] | Vale.AES.X64.PolyOps.va_quick_VLow64ToHigh | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.AES.X64.PolyOps.va_code_VLow64ToHigh dst src) | {
"end_col": 43,
"end_line": 187,
"start_col": 2,
"start_line": 186
} |
Prims.Tot | val va_quick_VSwap (dst src: va_operand_xmm) : (va_quickCode unit (va_code_VSwap dst src)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_VSwap
dst src)) =
(va_QProc (va_code_VSwap dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VSwap dst src)
(va_wpProof_VSwap dst src)) | val va_quick_VSwap (dst src: va_operand_xmm) : (va_quickCode unit (va_code_VSwap dst src))
let va_quick_VSwap (dst src: va_operand_xmm) : (va_quickCode unit (va_code_VSwap dst src)) = | false | null | false | (va_QProc (va_code_VSwap dst src)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VSwap dst src)
(va_wpProof_VSwap dst src)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_VSwap",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_VSwap",
"Vale.AES.X64.PolyOps.va_wpProof_VSwap",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (())))
val va_wpProof_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VLow64ToHigh dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VLow64ToHigh dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VLow64ToHigh dst src)) =
(va_QProc (va_code_VLow64ToHigh dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VLow64ToHigh dst
src) (va_wpProof_VLow64ToHigh dst src))
//--
//-- VSwap
val va_code_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VSwap : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VSwap dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) ==> va_k
va_sM (())))
val va_wpProof_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VSwap dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VSwap dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_VSwap | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_VSwap (dst src: va_operand_xmm) : (va_quickCode unit (va_code_VSwap dst src)) | [] | Vale.AES.X64.PolyOps.va_quick_VSwap | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.AES.X64.PolyOps.va_code_VSwap dst src) | {
"end_col": 31,
"end_line": 226,
"start_col": 2,
"start_line": 225
} |
Prims.Tot | val va_quick_VPolyMul (dst src1 src2: va_operand_xmm) (src1Hi src2Hi: bool)
: (va_quickCode unit (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)) | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let va_quick_VPolyMul (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm)
(src1Hi:bool) (src2Hi:bool) : (va_quickCode unit (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)) =
(va_QProc (va_code_VPolyMul dst src1 src2 src1Hi src2Hi) ([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPolyMul dst src1 src2 src1Hi src2Hi) (va_wpProof_VPolyMul dst src1 src2 src1Hi src2Hi)) | val va_quick_VPolyMul (dst src1 src2: va_operand_xmm) (src1Hi src2Hi: bool)
: (va_quickCode unit (va_code_VPolyMul dst src1 src2 src1Hi src2Hi))
let va_quick_VPolyMul (dst src1 src2: va_operand_xmm) (src1Hi src2Hi: bool)
: (va_quickCode unit (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)) = | false | null | false | (va_QProc (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)
([va_Mod_flags; va_mod_xmm dst])
(va_wp_VPolyMul dst src1 src2 src1Hi src2Hi)
(va_wpProof_VPolyMul dst src1 src2 src1Hi src2Hi)) | {
"checked_file": "Vale.AES.X64.PolyOps.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.PolyOps.fsti"
} | [
"total"
] | [
"Vale.X64.Decls.va_operand_xmm",
"Prims.bool",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.PolyOps.va_code_VPolyMul",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_mod_xmm",
"Prims.Nil",
"Vale.AES.X64.PolyOps.va_wp_VPolyMul",
"Vale.AES.X64.PolyOps.va_wpProof_VPolyMul",
"Vale.X64.QuickCode.va_quickCode"
] | [] | module Vale.AES.X64.PolyOps
open Vale.Def.Types_s
open Vale.Arch.Types
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
//-- VPolyAdd
val va_code_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 -> Tot
va_code
val va_codegen_success_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm ->
src2:va_operand_opr128 -> Tot va_pbool
val va_lemma_VPolyAdd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_opr128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyAdd dst src1 src2) va_s0 /\ va_is_dst_xmm dst
va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2) in
avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_opr128 src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128
va_s0 src2) in avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) .
let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_opr128 va_s0 src2)
in Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.add a1 a2) ==>
va_k va_sM (())))
val va_wpProof_VPolyAdd : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_opr128 ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyAdd dst src1 src2 va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyAdd dst src1 src2)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyAdd (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_opr128) :
(va_quickCode unit (va_code_VPolyAdd dst src1 src2)) =
(va_QProc (va_code_VPolyAdd dst src1 src2) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VPolyAdd dst
src1 src2) (va_wpProof_VPolyAdd dst src1 src2))
//--
//-- PolyAnd
val va_code_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_PolyAnd : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_PolyAnd dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in sse_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state ->
unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
sse_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 dst) in let
(a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.poly_and a1 a2) ==>
va_k va_sM (())))
val va_wpProof_PolyAnd : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_PolyAnd dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_PolyAnd dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_PolyAnd (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_PolyAnd dst src)) =
(va_QProc (va_code_PolyAnd dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_PolyAnd dst src)
(va_wpProof_PolyAnd dst src))
//--
//-- VHigh64ToLow
val va_code_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VHigh64ToLow : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VHigh64ToLow dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64)) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift a (-64))
==> va_k va_sM (())))
val va_wpProof_VHigh64ToLow : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VHigh64ToLow dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VHigh64ToLow dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VHigh64ToLow (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VHigh64ToLow dst src)) =
(va_QProc (va_code_VHigh64ToLow dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VHigh64ToLow dst
src) (va_wpProof_VHigh64ToLow dst src))
//--
//-- VLow64ToHigh
val va_code_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VLow64ToHigh : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VLow64ToHigh dst src) va_s0 /\ va_is_dst_xmm dst va_s0
/\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM
(va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state
-> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.shift
(Vale.Math.Poly2.mask a 64) 64) ==> va_k va_sM (())))
val va_wpProof_VLow64ToHigh : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state ->
va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VLow64ToHigh dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VLow64ToHigh dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VLow64ToHigh (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit
(va_code_VLow64ToHigh dst src)) =
(va_QProc (va_code_VLow64ToHigh dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VLow64ToHigh dst
src) (va_wpProof_VLow64ToHigh dst src))
//--
//-- VSwap
val va_code_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code
val va_codegen_success_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool
val va_lemma_VSwap : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm -> src:va_operand_xmm
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VSwap dst src) va_s0 /\ va_is_dst_xmm dst va_s0 /\
va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let (a:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) /\
va_state_eq va_sM (va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM
va_s0)))))
[@ va_qattr]
let va_wp_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) (va_s0:va_state) (va_k:(va_state -> unit
-> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src va_s0 /\ va_get_ok va_s0 /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
avx_enabled) /\ (forall (va_x_dst:va_value_xmm) (va_x_efl:Vale.X64.Flags.t) . let va_sM =
va_upd_flags va_x_efl (va_upd_operand_xmm dst va_x_dst va_s0) in va_get_ok va_sM /\ (let
(a:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2.swap a 64) ==> va_k
va_sM (())))
val va_wpProof_VSwap : dst:va_operand_xmm -> src:va_operand_xmm -> va_s0:va_state -> va_k:(va_state
-> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VSwap dst src va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VSwap dst src) ([va_Mod_flags;
va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VSwap (dst:va_operand_xmm) (src:va_operand_xmm) : (va_quickCode unit (va_code_VSwap
dst src)) =
(va_QProc (va_code_VSwap dst src) ([va_Mod_flags; va_mod_xmm dst]) (va_wp_VSwap dst src)
(va_wpProof_VSwap dst src))
//--
//-- VPolyMul
val va_code_VPolyMul : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
src1Hi:bool -> src2Hi:bool -> Tot va_code
val va_codegen_success_VPolyMul : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm
-> src1Hi:bool -> src2Hi:bool -> Tot va_pbool
val va_lemma_VPolyMul : va_b0:va_code -> va_s0:va_state -> dst:va_operand_xmm ->
src1:va_operand_xmm -> src2:va_operand_xmm -> src1Hi:bool -> src2Hi:bool
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_VPolyMul dst src1 src2 src1Hi src2Hi) va_s0 /\
va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src2) in pclmulqdq_enabled /\ avx_enabled)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in
let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.mul (if src1Hi
then Vale.Math.Poly2_s.shift a1 (-64) else Vale.Math.Poly2.mask a1 64) (if src2Hi then
Vale.Math.Poly2_s.shift a2 (-64) else Vale.Math.Poly2.mask a2 64)) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)))))
[@ va_qattr]
let va_wp_VPolyMul (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) (src1Hi:bool)
(src2Hi:bool) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_is_dst_xmm dst va_s0 /\ va_is_src_xmm src1 va_s0 /\ va_is_src_xmm src2 va_s0 /\ va_get_ok
va_s0 /\ (let (a1:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src1) in let (a2:Vale.Math.Poly2_s.poly) = Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0
src2) in pclmulqdq_enabled /\ avx_enabled) /\ (forall (va_x_dst:va_value_xmm)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_operand_xmm dst
va_x_dst va_s0) in va_get_ok va_sM /\ (let (a1:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src1) in let (a2:Vale.Math.Poly2_s.poly) =
Vale.Math.Poly2.Bits_s.of_quad32 (va_eval_xmm va_s0 src2) in Vale.Math.Poly2.Bits_s.of_quad32
(va_eval_xmm va_sM dst) == Vale.Math.Poly2_s.mul (va_if src1Hi (fun _ ->
Vale.Math.Poly2_s.shift a1 (-64)) (fun _ -> Vale.Math.Poly2.mask a1 64)) (va_if src2Hi (fun _
-> Vale.Math.Poly2_s.shift a2 (-64)) (fun _ -> Vale.Math.Poly2.mask a2 64))) ==> va_k va_sM
(())))
val va_wpProof_VPolyMul : dst:va_operand_xmm -> src1:va_operand_xmm -> src2:va_operand_xmm ->
src1Hi:bool -> src2Hi:bool -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_VPolyMul dst src1 src2 src1Hi src2Hi va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)
([va_Mod_flags; va_mod_xmm dst]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_VPolyMul (dst:va_operand_xmm) (src1:va_operand_xmm) (src2:va_operand_xmm) | false | false | Vale.AES.X64.PolyOps.fsti | {
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val va_quick_VPolyMul (dst src1 src2: va_operand_xmm) (src1Hi src2Hi: bool)
: (va_quickCode unit (va_code_VPolyMul dst src1 src2 src1Hi src2Hi)) | [] | Vale.AES.X64.PolyOps.va_quick_VPolyMul | {
"file_name": "obj/Vale.AES.X64.PolyOps.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Decls.va_operand_xmm ->
src1: Vale.X64.Decls.va_operand_xmm ->
src2: Vale.X64.Decls.va_operand_xmm ->
src1Hi: Prims.bool ->
src2Hi: Prims.bool
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.PolyOps.va_code_VPolyMul dst src1 src2 src1Hi src2Hi) | {
"end_col": 99,
"end_line": 277,
"start_col": 2,
"start_line": 276
} |
Prims.Tot | val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5 | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4) | val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi = | false | null | false | let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"total"
] | [
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Lib.IntTypes.u64",
"Hacl.Spec.Poly1305.Field32xN.tup64_5"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract | false | true | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5 | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64 -> Hacl.Spec.Poly1305.Field32xN.tup64_5 | {
"end_col": 22,
"end_line": 232,
"start_col": 32,
"start_line": 224
} |
FStar.Pervasives.Lemma | val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26) | val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b = | false | null | true | assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Modulus",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.pos",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Prims.unit",
"FStar.Math.Lemmas.pow2_double_sum",
"Prims._assert",
"Prims.op_Addition",
"FStar.Math.Lemmas.pow2_le_compat"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lemma_sum_lt_pow2_26 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Prims.nat -> a: Prims.nat{a < Prims.pow2 (i % 26)} -> b: Prims.nat{b <= Prims.pow2 (i % 26)}
-> FStar.Pervasives.Lemma (ensures a + b <= Hacl.Spec.Poly1305.Field32xN.max26) | {
"end_col": 31,
"end_line": 528,
"start_col": 2,
"start_line": 524
} |
FStar.Pervasives.Lemma | val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26) | val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_mult_le",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Prims.pos",
"Hacl.Spec.Poly1305.Field32xN.pow26"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_fits_lemma | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.tup64_5 -> lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Lib.IntTypes.v f0 == Lib.IntTypes.v lo % Prims.pow2 26 /\
Lib.IntTypes.v f1 == Lib.IntTypes.v lo / Prims.pow2 26 % Prims.pow2 26 /\
Lib.IntTypes.v f2 ==
Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12 /\
Lib.IntTypes.v f3 == Lib.IntTypes.v hi / Prims.pow2 14 % Prims.pow2 26 /\
Lib.IntTypes.v f4 == Lib.IntTypes.v hi / Prims.pow2 40)
<:
Type0)) (ensures Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1)) | {
"end_col": 33,
"end_line": 119,
"start_col": 35,
"start_line": 112
} |
FStar.Pervasives.Lemma | val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128) | val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f = | false | null | true | let f0, f1, f2, f3, f4 = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <=
pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 + (pow2 26 - 1) * pow78 +
(pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Lib.IntTypes.uint64",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"Prims.unit",
"Prims._assert",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Modulus"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lemma_tup64_pow2_128 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.tup64_5
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Hacl.Spec.Poly1305.Field32xN.pow26 +
Lib.IntTypes.v f2 * Hacl.Spec.Poly1305.Field32xN.pow52 +
Lib.IntTypes.v f3 * Hacl.Spec.Poly1305.Field32xN.pow78 +
(Lib.IntTypes.v f4 % Prims.pow2 24) * Hacl.Spec.Poly1305.Field32xN.pow104 <
Prims.pow2 128)
<:
Type0)) | {
"end_col": 43,
"end_line": 431,
"start_col": 28,
"start_line": 425
} |
Prims.Pure | val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f | val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi = | false | null | false | let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [] | [
"Lib.IntTypes.uint64",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"Hacl.Spec.Poly1305.Vec.prime",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Math.Lemmas.small_modulo_lemma_1",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_fits_lemma",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"FStar.Pervasives.Native.Mktuple5",
"Prims.op_Division",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Amp_Dot",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma_f2",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.mod_mask_lemma",
"Prims.op_Equality",
"Prims.op_Subtraction",
"Lib.IntTypes.range",
"Hacl.Spec.Poly1305.Field32xN.tup64_5"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> Prims.Pure Hacl.Spec.Poly1305.Field32xN.tup64_5 | {
"end_col": 3,
"end_line": 205,
"start_col": 28,
"start_line": 175
} |
FStar.Pervasives.Lemma | val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi | val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi = | false | null | true | let l0, l1, l2, l3, l4 = load_tup64_4_compact lo hi in
let r0, r1, r2, r3, r4 = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f3",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.pow2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.mod_mask_lemma",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma_f2",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f2",
"Lib.IntTypes.range",
"Prims.l_and",
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 -> | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact lo hi ==
Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma lo hi) | {
"end_col": 37,
"end_line": 355,
"start_col": 38,
"start_line": 336
} |
FStar.Pervasives.Lemma | val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26) | val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i = | false | null | true | let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims._assert",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Poly1305.Field32xN.max26",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.pos",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Prims.pow2",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_sum_lt_pow2_26",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Prims.op_Modulus",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.logor_disjoint",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.op_GreaterThan",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Math.Lemmas.pow2_lt_compat",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.size"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26))) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26))) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma_aux | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | fi: Lib.IntTypes.uint64 -> i: Lib.IntTypes.size_nat{i <= 128}
-> FStar.Pervasives.Lemma (requires Lib.IntTypes.v fi < Prims.pow2 (i % 26))
(ensures
Lib.IntTypes.v (fi |. Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26)) ==
Lib.IntTypes.v fi + Prims.pow2 (i % 26)) | {
"end_col": 27,
"end_line": 548,
"start_col": 30,
"start_line": 536
} |
FStar.Pervasives.Lemma | val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52 | val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
let lemma_store_felem_lo f lo = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52 | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Hacl.Spec.Poly1305.Field32xN.tup64_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Prims.pow2",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"FStar.Math.Lemmas.modulo_lemma",
"Lib.IntTypes.int_t",
"Hacl.Spec.Poly1305.Field32xN.max26",
"Prims.op_Subtraction"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200" | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lemma_store_felem_lo | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Poly1305.Field32xN.tup64_5
{Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1)} ->
lo: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 _ _ = _ in
let lo = f0 |. f1 <<. 26ul |. f2 <<. 52ul in
Lib.IntTypes.v lo ==
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Prims.pow2 26 +
Lib.IntTypes.v f2 * Prims.pow2 52 % Prims.pow2 64)
<:
Type0)) | {
"end_col": 55,
"end_line": 381,
"start_col": 31,
"start_line": 368
} |
FStar.Pervasives.Lemma | val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i]) | val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i = | false | null | true | assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[ i ] (vec_v hi).[ i ]) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.uint64xN",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Hacl.Spec.Poly1305.Field32xN.as_tup64_i",
"Hacl.Spec.Poly1305.Field32xN.load_felem5",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntVector.vec_v",
"Prims.unit"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i]) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_felem5_lemma_i | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
lo: Hacl.Spec.Poly1305.Field32xN.uint64xN w ->
hi: Hacl.Spec.Poly1305.Field32xN.uint64xN w ->
i: Prims.nat{i < w}
-> FStar.Pervasives.Lemma
(ensures
(let f =
Hacl.Spec.Poly1305.Field32xN.as_tup64_i (Hacl.Spec.Poly1305.Field32xN.load_felem5 lo hi) i
in
Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 f < Prims.pow2 128 /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 f % Hacl.Spec.Poly1305.Vec.prime ==
(Hacl.Spec.Poly1305.Field32xN.uint64xN_v hi).[ i ] * Prims.pow2 64 +
(Hacl.Spec.Poly1305.Field32xN.uint64xN_v lo).[ i ])) | {
"end_col": 96,
"end_line": 220,
"start_col": 2,
"start_line": 220
} |
FStar.Pervasives.Lemma | val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi)) | val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f = | false | null | true | let lo, hi = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi)) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Poly1305.Field32xN.Lemmas2.store_tup64_lemma",
"Hacl.Spec.Poly1305.Field32xN.as_tup64_i",
"FStar.Pervasives.Native.Mktuple2",
"Prims.unit",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Poly1305.Field32xN.store_felem5"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.store_felem5_lemma | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.felem5 w
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let _ = Hacl.Spec.Poly1305.Field32xN.store_felem5 f in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ lo hi = _ in
Lib.IntTypes.v hi * Prims.pow2 64 + Lib.IntTypes.v lo ==
(Hacl.Spec.Poly1305.Field32xN.fas_nat5 f).[ 0 ] % Prims.pow2 128)
<:
Type0)) | {
"end_col": 57,
"end_line": 517,
"start_col": 29,
"start_line": 515
} |
FStar.Pervasives.Lemma | val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40 | val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40 | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Lib.IntTypes.uint64",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Less_Less_Dot",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Prims.pow2",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Prims.op_LessThan",
"Prims.op_Addition",
"Prims.op_Division",
"FStar.Math.Lemmas.lemma_mult_le_right",
"Prims.op_Subtraction",
"Prims.eq2",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Pervasives.assert_norm",
"FStar.Math.Lemmas.lemma_div_lt",
"Lib.IntTypes.int_t",
"Hacl.Spec.Poly1305.Field32xN.max26"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lemma_store_felem_hi | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.tup64_5 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ f2 f3 f4 = _ in
let hi = f2 >>. 12ul |. f3 <<. 14ul |. f4 <<. 40ul in
Lib.IntTypes.v hi ==
Lib.IntTypes.v f2 / Prims.pow2 12 + Lib.IntTypes.v f3 * Prims.pow2 14 +
Lib.IntTypes.v f4 * Prims.pow2 40 % Prims.pow2 64)
<:
Type0)) | {
"end_col": 66,
"end_line": 415,
"start_col": 31,
"start_line": 392
} |
FStar.Pervasives.Lemma | val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26) | val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi = | false | null | true | calc ( < ) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
( < ) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
( <= ) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
( == ) { (Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12);
Math.Lemmas.pow2_plus 14 12) }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.small_modulo_lemma_1",
"Prims.op_Addition",
"Prims.op_Division",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.eq2",
"Prims.op_LessThanOrEqual",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_div_lt",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mult_le_right",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.distributivity_sub_left"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f2_mod | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12) %
Prims.pow2 26 ==
Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12) | {
"end_col": 90,
"end_line": 247,
"start_col": 2,
"start_line": 237
} |
FStar.Pervasives.Lemma | val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
} | val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo = | false | null | true | calc ( == ) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + (v lo / pow2 52) * pow52;
( == ) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + (v lo / pow2 52) * pow2 52;
( == ) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + (v lo / pow2 52) * pow2 52;
( == ) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + (v lo / pow2 52) * pow2 52;
( == ) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
} | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"FStar.Math.Lemmas.euclidean_division_definition"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0_lo | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v lo % Prims.pow2 26 +
(Lib.IntTypes.v lo / Prims.pow2 26 % Prims.pow2 26) * Hacl.Spec.Poly1305.Field32xN.pow26 +
(Lib.IntTypes.v lo / Prims.pow2 52) * Hacl.Spec.Poly1305.Field32xN.pow52 ==
Lib.IntTypes.v lo) | {
"end_col": 3,
"end_line": 35,
"start_col": 2,
"start_line": 25
} |
FStar.Pervasives.Lemma | val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5_ f i =
let ind = i / 26 in
let j = i % 26 in
FStar.Math.Lemmas.euclidean_division_definition i 26;
assert (i == ind * 26 + j);
match ind with
| 0 -> lset_bit5_lemma0 f i
| 1 -> lset_bit5_lemma1 f i
| 2 -> lset_bit5_lemma2 f i
| 3 -> lset_bit5_lemma3 f i
| 4 -> lset_bit5_lemma4 f i | val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_ f i = | false | null | true | let ind = i / 26 in
let j = i % 26 in
FStar.Math.Lemmas.euclidean_division_definition i 26;
assert (i == ind * 26 + j);
match ind with
| 0 -> lset_bit5_lemma0 f i
| 1 -> lset_bit5_lemma1 f i
| 2 -> lset_bit5_lemma2 f i
| 3 -> lset_bit5_lemma3 f i
| 4 -> lset_bit5_lemma4 f i | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma0",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma1",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma2",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma3",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma4",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.op_Modulus",
"Prims.op_Division"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma1:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 1} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma1 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[1] <- f.[1] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f1 * pow2 26 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f1 * pow2 26) i 26;
assert (v f1 < pow2 (i - 26));
assert (i - 26 == i % 26);
assert (v f.[1] < pow2 (i % 26));
lset_bit5_lemma_aux f.[1] i;
assert (v out.[1] == v f.[1] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[1]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow26 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 26 }
pow2 (i % 26 + 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma2 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[2] <- f.[2] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[2] < pow2 (i % 26));
lset_bit5_lemma_aux f.[2] i;
assert (v out.[2] == v f.[2] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[2]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma3 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[3] <- f.[3] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f3 * pow78 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f3 * pow78) i 78;
assert (v f3 < pow2 (i - 78));
assert (i - 78 == i % 26);
assert (v f.[3] < pow2 (i % 26));
lset_bit5_lemma_aux f.[3] i;
assert (v out.[3] == v f.[3] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[3]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow78 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 78 }
pow2 (i % 26 + 78) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma4:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 4} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma4 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[4] <- f.[4] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f4 * pow104 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f4 * pow104) i 104;
assert (v f4 < pow2 (i - 104));
assert (i - 104 == i % 26);
assert (v f.[4] < pow2 (i % 26));
lset_bit5_lemma_aux f.[4] i;
assert (v out.[4] == v f.[4] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[4]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow104 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 104 }
pow2 (i % 26 + 104) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_ | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> i: Lib.IntTypes.size_nat{i <= 128}
-> FStar.Pervasives.Lemma
(requires
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v f.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) <
Prims.pow2 i)
(ensures
(let b = Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v out.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (out.[ 0 ],
out.[ 1 ],
out.[ 2 ],
out.[ 3 ],
out.[ 4 ]) ==
Prims.pow2 i +
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]))) | {
"end_col": 29,
"end_line": 780,
"start_col": 20,
"start_line": 769
} |
FStar.Pervasives.Lemma | val lset_bit5:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) % prime ==
(pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) % prime) % prime)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
lset_bit5_ f i;
let out = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
let f = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
assert (as_nat5 out % prime == (pow2 i + as_nat5 f) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r (pow2 i) (as_nat5 f) prime | val lset_bit5:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) % prime ==
(pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) % prime) % prime))
let lset_bit5 f i = | false | null | true | let b = u64 1 <<. size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
lset_bit5_ f i;
let out = (out.[ 0 ], out.[ 1 ], out.[ 2 ], out.[ 3 ], out.[ 4 ]) in
let f = (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) in
assert (as_nat5 out % prime == (pow2 i + as_nat5 f) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r (pow2 i) (as_nat5 f) prime | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.pow2",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"Hacl.Spec.Poly1305.Vec.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.Mktuple5",
"Lib.Sequence.op_String_Access",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Prims.op_Division",
"Lib.IntTypes.logor",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_Subtraction",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.size"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma1:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 1} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma1 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[1] <- f.[1] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f1 * pow2 26 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f1 * pow2 26) i 26;
assert (v f1 < pow2 (i - 26));
assert (i - 26 == i % 26);
assert (v f.[1] < pow2 (i % 26));
lset_bit5_lemma_aux f.[1] i;
assert (v out.[1] == v f.[1] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[1]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow26 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 26 }
pow2 (i % 26 + 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma2 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[2] <- f.[2] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[2] < pow2 (i % 26));
lset_bit5_lemma_aux f.[2] i;
assert (v out.[2] == v f.[2] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[2]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma3 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[3] <- f.[3] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f3 * pow78 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f3 * pow78) i 78;
assert (v f3 < pow2 (i - 78));
assert (i - 78 == i % 26);
assert (v f.[3] < pow2 (i % 26));
lset_bit5_lemma_aux f.[3] i;
assert (v out.[3] == v f.[3] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[3]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow78 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 78 }
pow2 (i % 26 + 78) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma4:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 4} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma4 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[4] <- f.[4] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f4 * pow104 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f4 * pow104) i 104;
assert (v f4 < pow2 (i - 104));
assert (i - 104 == i % 26);
assert (v f.[4] < pow2 (i % 26));
lset_bit5_lemma_aux f.[4] i;
assert (v out.[4] == v f.[4] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[4]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow104 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 104 }
pow2 (i % 26 + 104) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_ f i =
let ind = i / 26 in
let j = i % 26 in
FStar.Math.Lemmas.euclidean_division_definition i 26;
assert (i == ind * 26 + j);
match ind with
| 0 -> lset_bit5_lemma0 f i
| 1 -> lset_bit5_lemma1 f i
| 2 -> lset_bit5_lemma2 f i
| 3 -> lset_bit5_lemma3 f i
| 4 -> lset_bit5_lemma4 f i
val lset_bit5:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) % prime ==
(pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) % prime) % prime)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) % prime ==
(pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) % prime) % prime)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> i: Lib.IntTypes.size_nat{i <= 128}
-> FStar.Pervasives.Lemma
(requires
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v f.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) <
Prims.pow2 i)
(ensures
(let b = Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v out.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (out.[ 0 ],
out.[ 1 ],
out.[ 2 ],
out.[ 3 ],
out.[ 4 ]) %
Hacl.Spec.Poly1305.Vec.prime ==
(Prims.pow2 i +
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) %
Hacl.Spec.Poly1305.Vec.prime) %
Hacl.Spec.Poly1305.Vec.prime)) | {
"end_col": 69,
"end_line": 803,
"start_col": 19,
"start_line": 796
} |
FStar.Pervasives.Lemma | val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi = | false | null | true | let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc ( == ) {
v (tmp <<. 12ul) % pow2 12;
( == ) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
( == ) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
( == ) { FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52) }
v tmp * pow2 12 % pow2 12;
( == ) { FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12) }
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc ( == ) {
v f2;
( == ) { () }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
( == ) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
( == ) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.unit",
"FStar.Math.Lemmas.small_modulo_lemma_1",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.u64",
"Lib.IntTypes.mod_mask_lemma",
"Prims.op_Equality",
"Prims.op_Subtraction",
"Lib.IntTypes.op_Amp_Dot",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Lib.IntTypes.shift_right_lemma",
"Lib.IntTypes.shift_left_lemma",
"Lib.IntTypes.logor_disjoint",
"FStar.Math.Lemmas.lemma_div_lt",
"FStar.Math.Lemmas.modulo_modulo_lemma",
"FStar.Math.Lemmas.multiple_modulo_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Bar_Dot"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma_f2 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
Lib.IntTypes.v (lo >>. 52ul |. (hi &. Lib.IntTypes.u64 0x3fff) <<. 12ul) ==
Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12) | {
"end_col": 62,
"end_line": 164,
"start_col": 31,
"start_line": 126
} |
FStar.Pervasives.Lemma | val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34 | val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
let load_tup64_4_compact_lemma_f3 lo hi = | false | null | true | let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc ( == ) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
( == ) { (Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16)
(pow2 16)
(pow2 14)) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
( == ) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
( == ) { (Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16);
Math.Lemmas.pow2_plus 48 16) }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
( == ) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
( == ) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34 | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Prims.op_Division",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.u64",
"Lib.IntTypes.mod_mask_lemma",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Subtraction",
"FStar.Calc.calc_finish",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"Prims.squash",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.division_addition_lemma",
"FStar.Math.Lemmas.small_div",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.op_Less_Less_Dot",
"FStar.Math.Lemmas.lemma_div_lt",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Bar_Dot"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 200,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f3 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let t3 = lo >>. 48ul |. hi <<. 16ul in
Lib.IntTypes.v (t3 >>. 30ul &. Lib.IntTypes.u64 0x3ffffff) ==
Lib.IntTypes.v hi / Prims.pow2 14 % Prims.pow2 26)) | {
"end_col": 63,
"end_line": 331,
"start_col": 41,
"start_line": 301
} |
FStar.Pervasives.Lemma | val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104)) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104) | val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f = | false | null | true | let f0, f1, f2, f3, f4 = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc ( == ) {
(as_nat5 f) % pow2 128;
( == ) { () }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
( == ) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
( == ) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
( == ) { (lemma_tup64_pow2_128 f;
FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128)) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"Prims.pow2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"FStar.Math.Lemmas.modulo_lemma",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_tup64_pow2_128"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104)) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104)) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lemma_tup64_mod_pow2_128 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.tup64_5
-> FStar.Pervasives.Lemma (requires Hacl.Spec.Poly1305.Field32xN.tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Hacl.Spec.Poly1305.Field32xN.as_nat5 f % Prims.pow2 128 ==
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Hacl.Spec.Poly1305.Field32xN.pow26 +
Lib.IntTypes.v f2 * Hacl.Spec.Poly1305.Field32xN.pow52 +
Lib.IntTypes.v f3 * Hacl.Spec.Poly1305.Field32xN.pow78 +
(Lib.IntTypes.v f4 % Prims.pow2 24) * Hacl.Spec.Poly1305.Field32xN.pow104)
<:
Type0)) | {
"end_col": 68,
"end_line": 456,
"start_col": 32,
"start_line": 441
} |
FStar.Pervasives.Lemma | val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo) | val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
let load_tup64_lemma0 f lo hi = | false | null | true | let f0, f1, f2, f3, f4 = f in
calc ( == ) {
as_nat5 f;
( == ) { () }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
( == ) { () }
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + (v lo / pow2 52) * pow52 +
((v hi % pow2 14) * pow2 12) * pow52 +
((v hi / pow2 14) % pow2 26) * pow78 +
(v hi / pow2 40) * pow104;
( == ) { load_tup64_lemma0_lo lo }
v lo + ((v hi % pow2 14) * pow2 12) * pow52 + ((v hi / pow2 14) % pow2 26) * pow78 +
(v hi / pow2 40) * pow104;
( == ) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + ((v hi / pow2 14) % pow2 26) * pow78 +
(v hi / pow2 40) * pow104;
( == ) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.tup64_5",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"Prims.op_Division",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0_lo",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0_hi"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Poly1305.Field32xN.tup64_5 -> lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Lib.IntTypes.v f0 == Lib.IntTypes.v lo % Prims.pow2 26 /\
Lib.IntTypes.v f1 == Lib.IntTypes.v lo / Prims.pow2 26 % Prims.pow2 26 /\
Lib.IntTypes.v f2 ==
Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12 /\
Lib.IntTypes.v f3 == Lib.IntTypes.v hi / Prims.pow2 14 % Prims.pow2 26 /\
Lib.IntTypes.v f4 == Lib.IntTypes.v hi / Prims.pow2 40)
<:
Type0))
(ensures
Hacl.Spec.Poly1305.Field32xN.as_nat5 f ==
Lib.IntTypes.v hi * Prims.pow2 64 + Lib.IntTypes.v lo) | {
"end_col": 45,
"end_line": 95,
"start_col": 31,
"start_line": 78
} |
FStar.Pervasives.Lemma | val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2 lo hi = | false | null | true | let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc ( == ) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
( == ) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + ((v hi % pow2 48) * pow2 12) * pow2 4) / pow2 4;
( == ) { Math.Lemmas.division_addition_lemma (v lo / pow2 48)
(pow2 4)
((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
( == ) { (Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4);
Math.Lemmas.pow2_plus 48 4) }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc ( == ) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52)
((v hi * pow2 12) % pow2 60)
(pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
( == ) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
( == ) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.pow2",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f2_mod",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.u64",
"Lib.IntTypes.mod_mask_lemma",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.division_addition_lemma",
"FStar.Math.Lemmas.division_multiplication_lemma",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.op_Less_Less_Dot",
"FStar.Math.Lemmas.lemma_div_lt",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Bar_Dot"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_4_compact_lemma_f2 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | lo: Lib.IntTypes.uint64 -> hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let t3 = lo >>. 48ul |. hi <<. 16ul in
Lib.IntTypes.v (t3 >>. 4ul &. Lib.IntTypes.u64 0x3ffffff) ==
Lib.IntTypes.v lo / Prims.pow2 52 + (Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 12)) | {
"end_col": 62,
"end_line": 293,
"start_col": 41,
"start_line": 255
} |
FStar.Pervasives.Lemma | val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i = | false | null | true | let b = u64 1 <<. size (i % 26) in
let out = f.[ 0 ] <- f.[ 0 ] |. b in
assert (v f.[ i / 26 ] < pow2 (i % 26));
lset_bit5_lemma_aux f.[ 0 ] i;
assert (v out.[ 0 ] == v f.[ 0 ] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[ 0 ]) (pow2 (i % 26));
let f0, f1, f2, f3, f4 = (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) in
let o0, o1, o2, o3, o4 = (out.[ 0 ], out.[ 1 ], out.[ 2 ], out.[ 3 ], out.[ 4 ]) in
calc ( == ) {
as_nat5 (o0, o1, o2, o3, o4);
( == ) { () }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
( == ) { () }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
( == ) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Division",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.op_Addition",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.euclidean_division_definition",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"Lib.Sequence.op_String_Access",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_sum_lt_pow2_26",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma_aux",
"Prims.op_LessThan",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logor",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.op_Subtraction",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.size"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma0 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> i: Lib.IntTypes.size_nat{i <= 128 /\ i / 26 = 0}
-> FStar.Pervasives.Lemma
(requires
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v f.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) <
Prims.pow2 i)
(ensures
(let b = Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v out.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (out.[ 0 ],
out.[ 1 ],
out.[ 2 ],
out.[ 3 ],
out.[ 4 ]) ==
Prims.pow2 i +
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]))) | {
"end_col": 80,
"end_line": 584,
"start_col": 26,
"start_line": 565
} |
FStar.Pervasives.Lemma | val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
} | val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi = | false | null | true | calc ( == ) {
(v hi % pow2 14) * pow2 64 + ((v hi / pow2 14) % pow2 26) * pow78 + (v hi / pow2 40) * pow104;
( == ) { (assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)) }
(v hi % pow2 14) * pow2 64 + (((v hi / pow2 14) % pow2 26) * pow2 14) * pow2 64 +
((v hi / pow2 40) * pow2 40) * pow2 64;
( == ) { () }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
( == ) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
( == ) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) *
pow2 64;
( == ) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
( == ) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
} | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.op_Division",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"FStar.Math.Lemmas.euclidean_division_definition"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64) | [] | Hacl.Poly1305.Field32xN.Lemmas2.load_tup64_lemma0_hi | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | hi: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntTypes.v hi % Prims.pow2 14) * Prims.pow2 64 +
(Lib.IntTypes.v hi / Prims.pow2 14 % Prims.pow2 26) * Hacl.Spec.Poly1305.Field32xN.pow78 +
(Lib.IntTypes.v hi / Prims.pow2 40) * Hacl.Spec.Poly1305.Field32xN.pow104 ==
Lib.IntTypes.v hi * Prims.pow2 64) | {
"end_col": 3,
"end_line": 60,
"start_col": 2,
"start_line": 44
} |
FStar.Pervasives.Lemma | val set_bit5_lemma_k:
#w:lanes
-> f:lseq (uint64xN w) 5
-> i:size_nat{i <= 128}
-> k:nat{k < w} ->
Lemma
(requires
lfelem_fits f (1, 1, 1, 1, 1) /\
lfelem_less f (pow2 i))
(ensures (
let out = set_bit5 f i in
tup64_fits5 (as_tup64_i (as_tup5 out) k) (1, 1, 1, 1, 1) /\
(lfeval out).[k] == pfadd (pow2 i) (lfeval f).[k])) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let set_bit5_lemma_k #w f i k =
let lf = create 5 (u64 0) in
let lf = lf.[0] <- (vec_v f.[0]).[k] in
let lf = lf.[1] <- (vec_v f.[1]).[k] in
let lf = lf.[2] <- (vec_v f.[2]).[k] in
let lf = lf.[3] <- (vec_v f.[3]).[k] in
let lf = lf.[4] <- (vec_v f.[4]).[k] in
lset_bit5 lf i | val set_bit5_lemma_k:
#w:lanes
-> f:lseq (uint64xN w) 5
-> i:size_nat{i <= 128}
-> k:nat{k < w} ->
Lemma
(requires
lfelem_fits f (1, 1, 1, 1, 1) /\
lfelem_less f (pow2 i))
(ensures (
let out = set_bit5 f i in
tup64_fits5 (as_tup64_i (as_tup5 out) k) (1, 1, 1, 1, 1) /\
(lfeval out).[k] == pfadd (pow2 i) (lfeval f).[k]))
let set_bit5_lemma_k #w f i k = | false | null | true | let lf = create 5 (u64 0) in
let lf = lf.[ 0 ] <- (vec_v f.[ 0 ]).[ k ] in
let lf = lf.[ 1 ] <- (vec_v f.[ 1 ]).[ k ] in
let lf = lf.[ 2 ] <- (vec_v f.[ 2 ]).[ k ] in
let lf = lf.[ 3 ] <- (vec_v f.[ 3 ]).[ k ] in
let lf = lf.[ 4 ] <- (vec_v f.[ 4 ]).[ k ] in
lset_bit5 lf i | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Poly1305.Field32xN.lanes",
"Lib.Sequence.lseq",
"Hacl.Spec.Poly1305.Field32xN.uint64xN",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.nat",
"Prims.op_LessThan",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.Sequence.index",
"Lib.IntVector.vec_v",
"Prims.l_Forall",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint64",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.Sequence.create",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma1:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 1} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma1 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[1] <- f.[1] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f1 * pow2 26 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f1 * pow2 26) i 26;
assert (v f1 < pow2 (i - 26));
assert (i - 26 == i % 26);
assert (v f.[1] < pow2 (i % 26));
lset_bit5_lemma_aux f.[1] i;
assert (v out.[1] == v f.[1] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[1]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow26 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 26 }
pow2 (i % 26 + 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma2 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[2] <- f.[2] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[2] < pow2 (i % 26));
lset_bit5_lemma_aux f.[2] i;
assert (v out.[2] == v f.[2] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[2]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma3 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[3] <- f.[3] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f3 * pow78 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f3 * pow78) i 78;
assert (v f3 < pow2 (i - 78));
assert (i - 78 == i % 26);
assert (v f.[3] < pow2 (i % 26));
lset_bit5_lemma_aux f.[3] i;
assert (v out.[3] == v f.[3] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[3]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow78 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 78 }
pow2 (i % 26 + 78) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma4:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 4} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma4 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[4] <- f.[4] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f4 * pow104 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f4 * pow104) i 104;
assert (v f4 < pow2 (i - 104));
assert (i - 104 == i % 26);
assert (v f.[4] < pow2 (i % 26));
lset_bit5_lemma_aux f.[4] i;
assert (v out.[4] == v f.[4] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[4]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow104 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 104 }
pow2 (i % 26 + 104) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_ f i =
let ind = i / 26 in
let j = i % 26 in
FStar.Math.Lemmas.euclidean_division_definition i 26;
assert (i == ind * 26 + j);
match ind with
| 0 -> lset_bit5_lemma0 f i
| 1 -> lset_bit5_lemma1 f i
| 2 -> lset_bit5_lemma2 f i
| 3 -> lset_bit5_lemma3 f i
| 4 -> lset_bit5_lemma4 f i
val lset_bit5:
f:lseq uint64 5
-> i:size_nat{i <= 128} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) % prime ==
(pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) % prime) % prime))
let lset_bit5 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
lset_bit5_ f i;
let out = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
let f = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
assert (as_nat5 out % prime == (pow2 i + as_nat5 f) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r (pow2 i) (as_nat5 f) prime
val set_bit5_lemma_k:
#w:lanes
-> f:lseq (uint64xN w) 5
-> i:size_nat{i <= 128}
-> k:nat{k < w} ->
Lemma
(requires
lfelem_fits f (1, 1, 1, 1, 1) /\
lfelem_less f (pow2 i))
(ensures (
let out = set_bit5 f i in
tup64_fits5 (as_tup64_i (as_tup5 out) k) (1, 1, 1, 1, 1) /\
(lfeval out).[k] == pfadd (pow2 i) (lfeval f).[k])) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val set_bit5_lemma_k:
#w:lanes
-> f:lseq (uint64xN w) 5
-> i:size_nat{i <= 128}
-> k:nat{k < w} ->
Lemma
(requires
lfelem_fits f (1, 1, 1, 1, 1) /\
lfelem_less f (pow2 i))
(ensures (
let out = set_bit5 f i in
tup64_fits5 (as_tup64_i (as_tup5 out) k) (1, 1, 1, 1, 1) /\
(lfeval out).[k] == pfadd (pow2 i) (lfeval f).[k])) | [] | Hacl.Poly1305.Field32xN.Lemmas2.set_bit5_lemma_k | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f: Lib.Sequence.lseq (Hacl.Spec.Poly1305.Field32xN.uint64xN w) 5 ->
i: Lib.IntTypes.size_nat{i <= 128} ->
k: Prims.nat{k < w}
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Poly1305.Field32xN.lfelem_fits f (1, 1, 1, 1, 1) /\
Hacl.Spec.Poly1305.Field32xN.lfelem_less f (Prims.pow2 i))
(ensures
(let out = Hacl.Spec.Poly1305.Field32xN.set_bit5 f i in
Hacl.Spec.Poly1305.Field32xN.tup64_fits5 (Hacl.Spec.Poly1305.Field32xN.as_tup64_i (Hacl.Spec.Poly1305.Field32xN.as_tup5
out)
k)
(1, 1, 1, 1, 1) /\
(Hacl.Spec.Poly1305.Field32xN.lfeval out).[ k ] ==
Hacl.Spec.Poly1305.Vec.pfadd (Prims.pow2 i) (Hacl.Spec.Poly1305.Field32xN.lfeval f).[ k ])
) | {
"end_col": 16,
"end_line": 827,
"start_col": 31,
"start_line": 820
} |
FStar.Pervasives.Lemma | val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5_lemma2 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[2] <- f.[2] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[2] < pow2 (i % 26));
lset_bit5_lemma_aux f.[2] i;
assert (v out.[2] == v f.[2] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[2]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma2 f i = | false | null | true | let b = u64 1 <<. size (i % 26) in
let out = f.[ 2 ] <- f.[ 2 ] |. b in
let f0, f1, f2, f3, f4 = (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) in
let o0, o1, o2, o3, o4 = (out.[ 0 ], out.[ 1 ], out.[ 2 ], out.[ 3 ], out.[ 4 ]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[ 2 ] < pow2 (i % 26));
lset_bit5_lemma_aux f.[ 2 ] i;
assert (v out.[ 2 ] == v f.[ 2 ] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[ 2 ]) (pow2 (i % 26));
calc ( == ) {
as_nat5 (o0, o1, o2, o3, o4);
( == ) { () }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
( == ) { () }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
( == ) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
( == ) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Division",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.op_Addition",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.euclidean_division_definition",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_sum_lt_pow2_26",
"Lib.Sequence.op_String_Access",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma_aux",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logor",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.size"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma1:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 1} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma1 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[1] <- f.[1] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f1 * pow2 26 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f1 * pow2 26) i 26;
assert (v f1 < pow2 (i - 26));
assert (i - 26 == i % 26);
assert (v f.[1] < pow2 (i % 26));
lset_bit5_lemma_aux f.[1] i;
assert (v out.[1] == v f.[1] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[1]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow26 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 26 }
pow2 (i % 26 + 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma2 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> i: Lib.IntTypes.size_nat{i <= 128 /\ i / 26 = 2}
-> FStar.Pervasives.Lemma
(requires
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v f.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) <
Prims.pow2 i)
(ensures
(let b = Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v out.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (out.[ 0 ],
out.[ 1 ],
out.[ 2 ],
out.[ 3 ],
out.[ 4 ]) ==
Prims.pow2 i +
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]))) | {
"end_col": 80,
"end_line": 668,
"start_col": 26,
"start_line": 643
} |
FStar.Pervasives.Lemma | val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lset_bit5_lemma3 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[3] <- f.[3] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f3 * pow78 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f3 * pow78) i 78;
assert (v f3 < pow2 (i - 78));
assert (i - 78 == i % 26);
assert (v f.[3] < pow2 (i % 26));
lset_bit5_lemma_aux f.[3] i;
assert (v out.[3] == v f.[3] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[3]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow78 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 78 }
pow2 (i % 26 + 78) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma3 f i = | false | null | true | let b = u64 1 <<. size (i % 26) in
let out = f.[ 3 ] <- f.[ 3 ] |. b in
let f0, f1, f2, f3, f4 = (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) in
let o0, o1, o2, o3, o4 = (out.[ 0 ], out.[ 1 ], out.[ 2 ], out.[ 3 ], out.[ 4 ]) in
assert (v f3 * pow78 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f3 * pow78) i 78;
assert (v f3 < pow2 (i - 78));
assert (i - 78 == i % 26);
assert (v f.[ 3 ] < pow2 (i % 26));
lset_bit5_lemma_aux f.[ 3 ] i;
assert (v out.[ 3 ] == v f.[ 3 ] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[ 3 ]) (pow2 (i % 26));
calc ( == ) {
as_nat5 (o0, o1, o2, o3, o4);
( == ) { () }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
( == ) { () }
pow2 (i % 26) * pow78 + as_nat5 (f0, f1, f2, f3, f4);
( == ) { FStar.Math.Lemmas.pow2_plus (i % 26) 78 }
pow2 (i % 26 + 78) + as_nat5 (f0, f1, f2, f3, f4);
( == ) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4)) | {
"checked_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntVector.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Poly1305.Field32xN.Lemmas2.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Division",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Poly1305.Field32xN.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.op_Addition",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.Poly1305.Field32xN.pow78",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Poly1305.Field32xN.pow26",
"Hacl.Spec.Poly1305.Field32xN.pow52",
"Hacl.Spec.Poly1305.Field32xN.pow104",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.euclidean_division_definition",
"Hacl.Poly1305.Field32xN.Lemmas2.lemma_sum_lt_pow2_26",
"Lib.Sequence.op_String_Access",
"Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma_aux",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logor",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u64",
"Lib.IntTypes.size"
] | [] | module Hacl.Poly1305.Field32xN.Lemmas2
open Lib.IntTypes
open Lib.IntVector
open Lib.Sequence
open FStar.Mul
open FStar.Calc
open Hacl.Spec.Poly1305.Vec
include Hacl.Spec.Poly1305.Field32xN
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq' --max_fuel 0 --max_ifuel 0"
val lemma_mult_le: a:nat -> b:nat -> c:nat -> d:nat -> Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mult_le a b c d = ()
val load_tup64_lemma0_lo: lo:uint64 ->
Lemma
(v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 +
v lo / pow2 52 * pow52 == v lo)
let load_tup64_lemma0_lo lo =
calc (==) {
v lo % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow26 + v lo / pow2 52 * pow52;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo / pow2 26) % pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v lo) 26 52 }
(v lo % pow2 52) % pow2 26 + ((v lo % pow2 52) / pow2 26) * pow2 26 + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo % pow2 52) (pow2 26) }
(v lo % pow2 52) + v lo / pow2 52 * pow2 52;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v lo) (pow2 52) }
v lo;
}
val load_tup64_lemma0_hi: hi:uint64 ->
Lemma
((v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104 ==
v hi * pow2 64)
let load_tup64_lemma0_hi hi =
calc (==) {
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) {
assert_norm (pow78 = pow2 14 * pow2 64);
assert_norm (pow104 = pow2 40 * pow2 64)}
(v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow2 14 * pow2 64 + v hi / pow2 40 * pow2 40 * pow2 64;
(==) { }
(v hi % pow2 14 + ((v hi / pow2 14) % pow2 26) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 40 }
(v hi % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi) 14 40 }
((v hi % pow2 40) % pow2 14 + ((v hi % pow2 40) / pow2 14) * pow2 14 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi % pow2 40) (pow2 14) }
(v hi % pow2 40 + (v hi / pow2 40) * pow2 40) * pow2 64;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v hi) (pow2 40) }
v hi * pow2 64;
}
val load_tup64_lemma0:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures as_nat5 f == v hi * pow2 64 + v lo)
#push-options"--z3rlimit 100"
let load_tup64_lemma0 f lo hi =
let (f0, f1, f2, f3, f4) = f in
calc (==) {
as_nat5 f;
(==) { }
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104;
(==) { }
v lo % pow2 26 + (v lo / pow2 26) % pow2 26 * pow26 +
v lo / pow2 52 * pow52 + (v hi % pow2 14) * pow2 12 * pow52 +
(v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_lo lo }
v lo + (v hi % pow2 14) * pow2 12 * pow52 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v lo + (v hi % pow2 14) * pow2 64 + (v hi / pow2 14) % pow2 26 * pow78 + v hi / pow2 40 * pow104;
(==) { load_tup64_lemma0_hi hi }
v lo + v hi * pow2 64;
};
assert (as_nat5 f == v hi * pow2 64 + v lo)
#pop-options
val load_tup64_fits_lemma:
f:tup64_5
-> lo:uint64
-> hi:uint64 ->
Lemma
(requires
(let (f0, f1, f2, f3, f4) = f in
v f0 == v lo % pow2 26 /\
v f1 == (v lo / pow2 26) % pow2 26 /\
v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 /\
v f3 == (v hi / pow2 14) % pow2 26 /\
v f4 == v hi / pow2 40))
(ensures tup64_fits5 f (1, 1, 1, 1, 1))
let load_tup64_fits_lemma f lo hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow26 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v lo) 64 52;
lemma_mult_le (v hi % pow2 14) (pow2 14 - 1) (pow2 12) (pow2 12);
assert_norm (pow2 14 * pow2 12 = pow2 26);
FStar.Math.Lemmas.lemma_div_lt_nat (v hi) 64 40;
assert_norm (pow2 24 < pow2 26)
val load_tup64_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(v ((lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul)) ==
v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_lemma_f2 lo hi =
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
let tmp = (hi &. u64 0x3fff) in
calc (==) {
v (tmp <<. 12ul) % pow2 12;
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
(v tmp * pow2 12 % pow2 64) % pow2 12;
(==) { assert_norm (pow2 64 = pow2 12 * pow2 52) }
(v tmp * pow2 12 % (pow2 12 * pow2 52)) % pow2 12;
(==) {FStar.Math.Lemmas.modulo_modulo_lemma (v tmp * pow2 12) (pow2 12) (pow2 52)}
v tmp * pow2 12 % pow2 12;
(==) {FStar.Math.Lemmas.multiple_modulo_lemma (v tmp) (pow2 12)}
0;
};
assert (v (tmp <<. 12ul) % pow2 12 = 0);
FStar.Math.Lemmas.lemma_div_lt (v lo) 64 52;
assert (v (lo >>. 52ul) < pow2 12);
logor_disjoint (lo >>. 52ul) ((hi &. u64 0x3fff) <<. 12ul) 12;
calc (==) {
v f2;
(==) { }
v (lo >>. 52ul) + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_right_lemma lo 52ul }
v lo / pow2 52 + v ((hi &. u64 0x3fff) <<. 12ul);
(==) { shift_left_lemma (hi &. u64 0x3fff) 12ul }
v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64;
};
assert (v f2 == v lo / pow2 52 + v (hi &. u64 0x3fff) * pow2 12 % pow2 64);
assert_norm (0x3fff = pow2 14 - 1);
mod_mask_lemma hi 14ul;
assert (v (mod_mask #U64 #SEC 14ul) == v (u64 0x3fff));
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12 % pow2 64);
assert (v hi % pow2 14 < pow2 14);
assert_norm (pow2 14 * pow2 12 < pow2 64);
FStar.Math.Lemmas.small_modulo_lemma_1 ((v hi % pow2 14) * pow2 12) (pow2 64);
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
noextract
val load_tup64_lemma: lo:uint64 -> hi:uint64 ->
Pure tup64_5
(requires True)
(ensures fun f ->
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == v hi * pow2 64 + v lo)
let load_tup64_lemma lo hi =
let mask26 = u64 0x3ffffff in
assert_norm (0x3ffffff = pow2 26 - 1);
assert_norm (0x3fff = pow2 14 - 1);
let f0 = lo &. mask26 in
mod_mask_lemma lo 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v f0 == v lo % pow2 26);
let f1 = (lo >>. 26ul) &. mask26 in
assert (v f1 == (v lo / pow2 26) % pow2 26);
let f2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12);
let f3 = (hi >>. 14ul) &. mask26 in
assert (v f3 == (v hi / pow2 14) % pow2 26);
let f4 = hi >>. 40ul in
assert (v f4 == v hi / pow2 40);
let f = (f0, f1, f2, f3, f4) in
load_tup64_lemma0 f lo hi;
load_tup64_fits_lemma f lo hi;
assert (as_nat5 f < pow2 128);
assert_norm (pow2 128 < prime);
FStar.Math.Lemmas.small_modulo_lemma_1 (as_nat5 f) prime;
assert (as_nat5 f % prime == v hi * pow2 64 + v lo);
f
val load_felem5_lemma_i:
#w:lanes
-> lo:uint64xN w
-> hi:uint64xN w
-> i:nat{i < w} ->
Lemma
(let f = as_tup64_i (load_felem5 #w lo hi) i in
tup64_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f < pow2 128 /\
as_nat5 f % prime == (uint64xN_v hi).[i] * pow2 64 + (uint64xN_v lo).[i])
let load_felem5_lemma_i #w lo hi i =
assert (as_tup64_i (load_felem5 #w lo hi) i == load_tup64_lemma (vec_v lo).[i] (vec_v hi).[i])
noextract
val load_tup64_4_compact: lo:uint64 -> hi:uint64 -> tup64_5
let load_tup64_4_compact lo hi =
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let o0 = lo &. mask26 in
let o1 = (lo >>. 26ul) &. mask26 in
let o2 = (t3 >>. 4ul) &. mask26 in
let o3 = (t3 >>. 30ul) &. mask26 in
let o4 = hi >>. 40ul in
(o0, o1, o2, o3, o4)
val load_tup64_4_compact_lemma_f2_mod: lo:uint64 -> hi:uint64 -> Lemma
((v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
let load_tup64_4_compact_lemma_f2_mod lo hi =
calc (<) {
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
(<) { Math.Lemmas.lemma_div_lt (v lo) 64 52 }
pow2 12 + (v hi % pow2 14) * pow2 12;
(<=) { Math.Lemmas.lemma_mult_le_right (pow2 12) (v hi % pow2 14) (pow2 14 - 1) }
pow2 12 + (pow2 14 - 1) * pow2 12;
(==) { Math.Lemmas.distributivity_sub_left (pow2 14) 1 (pow2 12); Math.Lemmas.pow2_plus 14 12 }
pow2 26;
};
assert (v lo / pow2 52 + (v hi % pow2 14) * pow2 12 < pow2 26);
Math.Lemmas.small_modulo_lemma_1 (v lo / pow2 52 + (v hi % pow2 14) * pow2 12) (pow2 26)
val load_tup64_4_compact_lemma_f2: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 4ul) &. u64 0x3ffffff) == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#push-options "--z3rlimit 100"
let load_tup64_4_compact_lemma_f2 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f2 = (t3 >>. 4ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 4;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 4;
(==) { Math.Lemmas.pow2_plus 12 4 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 12 * pow2 4) / pow2 4;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 4) ((v hi % pow2 48) * pow2 12) }
(v lo / pow2 48) / pow2 4 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 4); Math.Lemmas.pow2_plus 48 4 }
v lo / pow2 52 + (v hi % pow2 48) * pow2 12;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 60 12 }
v lo / pow2 52 + (v hi * pow2 12) % pow2 60;
};
assert (v (t3 >>. 4ul) == v lo / pow2 52 + (v hi * pow2 12) % pow2 60);
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f2 == v (t3 >>. 4ul) % pow2 26);
calc (==) {
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60) % pow2 26;
(==) { Math.Lemmas.lemma_mod_plus_distr_r (v lo / pow2 52) ((v hi * pow2 12) % pow2 60) (pow2 26) }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 60 % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi * pow2 12) 26 60 }
(v lo / pow2 52 + (v hi * pow2 12) % pow2 26) % pow2 26;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 26 12 }
(v lo / pow2 52 + (v hi % pow2 14) * pow2 12) % pow2 26;
(==) { load_tup64_4_compact_lemma_f2_mod lo hi }
v lo / pow2 52 + (v hi % pow2 14) * pow2 12;
};
assert (v f2 == v lo / pow2 52 + (v hi % pow2 14) * pow2 12)
#pop-options
val load_tup64_4_compact_lemma_f3: lo:uint64 -> hi:uint64 -> Lemma
(let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
v ((t3 >>. 30ul) &. u64 0x3ffffff) == (v hi / pow2 14) % pow2 26)
#push-options "--z3rlimit 200"
let load_tup64_4_compact_lemma_f3 lo hi =
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let f3 = (t3 >>. 30ul) &. u64 0x3ffffff in
Math.Lemmas.lemma_div_lt (v lo) 64 48;
logor_disjoint (lo >>. 48ul) (hi <<. 16ul) 16;
assert (v t3 == v lo / pow2 48 + (v hi * pow2 16) % pow2 64);
calc (==) {
(v lo / pow2 48 + (v hi * pow2 16) % pow2 64) / pow2 30;
(==) { Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v hi) 64 16 }
(v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 30;
(==) { Math.Lemmas.pow2_plus 16 14;
Math.Lemmas.division_multiplication_lemma (v lo / pow2 48 + (v hi % pow2 48) * pow2 16) (pow2 16) (pow2 14) }
((v lo / pow2 48 + (v hi % pow2 48) * pow2 16) / pow2 16) / pow2 14;
(==) { Math.Lemmas.division_addition_lemma (v lo / pow2 48) (pow2 16) (v hi % pow2 48) }
((v lo / pow2 48) / pow2 16 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.division_multiplication_lemma (v lo) (pow2 48) (pow2 16); Math.Lemmas.pow2_plus 48 16 }
(v lo / pow2 64 + (v hi % pow2 48)) / pow2 14;
(==) { Math.Lemmas.small_div (v lo) (pow2 64) }
(v hi % pow2 48) / pow2 14;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (v hi) 14 48 }
(v hi / pow2 14) % pow2 34;
};
assert_norm (0x3ffffff = pow2 26 - 1);
mod_mask_lemma (t3 >>. 4ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v (u64 0x3ffffff));
assert (v f3 == v (t3 >>. 30ul) % pow2 26);
assert (v f3 == ((v hi / pow2 14) % pow2 34) % pow2 26);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (v hi / pow2 14) 26 34
#pop-options
val load_tup64_4_compact_lemma: lo:uint64 -> hi:uint64 ->
Lemma (load_tup64_4_compact lo hi == load_tup64_lemma lo hi)
let load_tup64_4_compact_lemma lo hi =
let (l0, l1, l2, l3, l4) = load_tup64_4_compact lo hi in
let (r0, r1, r2, r3, r4) = load_tup64_lemma lo hi in
assert (l0 == r0 /\ l1 == r1 /\ l4 == r4);
let mask26 = u64 0x3ffffff in
let t3 = (lo >>. 48ul) |. (hi <<. 16ul) in
let l2 = (t3 >>. 4ul) &. mask26 in
load_tup64_4_compact_lemma_f2 lo hi;
let r2 = (lo >>. 52ul) |. ((hi &. u64 0x3fff) <<. 12ul) in
load_tup64_lemma_f2 lo hi;
assert (v l2 == v r2);
let r3 = (hi >>. 14ul) &. mask26 in
mod_mask_lemma (hi >>. 14ul) 26ul;
assert (v (mod_mask #U64 #SEC 26ul) == v mask26);
assert (v r3 == (v hi / pow2 14) % pow2 26);
let l3 = (t3 >>. 30ul) &. mask26 in
load_tup64_4_compact_lemma_f3 lo hi
val lemma_store_felem_lo:
f:tup64_5{tup64_fits5 f (1, 1, 1, 1, 1)}
-> lo:uint64 ->
Lemma
(let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64)
#push-options "--z3rlimit 200"
#restart-solver
let lemma_store_felem_lo f lo =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
assert (v (f1 <<. 26ul) == v f1 * pow2 26 % pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f1 * pow2 26) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f1) 26 26;
logor_disjoint f0 (f1 <<. 26ul) 26;
assert (v (f0 |. (f1 <<. 26ul)) == v f0 + v f1 * pow2 26);
assert_norm (pow2 26 * pow2 26 = pow2 52);
assert (v f0 + v f1 * pow2 26 < pow2 52);
assert (((v f2 * pow2 52) % pow2 64) % pow2 52 = 0);
logor_disjoint (f0 |. (f1 <<. 26ul)) (f2 <<. 52ul) 52
#pop-options
val lemma_store_felem_hi: f:tup64_5 -> hi:uint64 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64))
let lemma_store_felem_hi f hi =
let (f0, f1, f2, f3, f4) = f in
assert_norm (max26 = pow2 26 - 1);
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 26 12;
assert (v f2 / pow2 12 < pow2 14);
assert (v (f3 <<. 14ul) == v f3 * pow2 14 % pow2 64);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26);
assert_norm (pow2 26 * pow2 14 = pow2 40);
assert_norm (pow2 40 < pow2 64);
FStar.Math.Lemmas.modulo_lemma (v f3 * pow2 14) (pow2 64);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f3) 14 14;
assert ((v f3 * pow2 14) % pow2 14 = 0);
logor_disjoint (f2 >>. 12ul) (f3 <<. 14ul) 14;
assert (v ((f2 >>. 12ul) |. (f3 <<. 14ul)) == v f2 / pow2 12 + v f3 * pow2 14);
FStar.Math.Lemmas.lemma_mult_le_right (pow2 14) (v f3) (pow2 26 - 1);
assert (v f2 / pow2 12 + v f3 * pow2 14 < pow2 40);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v f4 * pow2 40) 40 64;
assert (((v f4 * pow2 40) % pow2 64) % pow2 40 = (v f4 * pow2 40) % pow2 40);
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1 (v f4) 40 40;
assert ((v f4 * pow2 40) % pow2 40 = 0);
logor_disjoint ((f2 >>. 12ul) |. (f3 <<. 14ul)) (f4 <<. 40ul) 40
val lemma_tup64_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 < pow2 128))
let lemma_tup64_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104 in
assert (tmp <= pow2 26 - 1 + (pow2 26 - 1) * pow26 + (pow2 26 - 1) * pow52 +
(pow2 26 - 1) * pow78 + (pow2 24 - 1) * pow104);
assert (tmp <= pow2 24 * pow104 - 1);
assert_norm (pow2 24 * pow104 = pow2 128)
val lemma_tup64_mod_pow2_128: f:tup64_5 ->
Lemma
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (f0, f1, f2, f3, f4) = f in
(as_nat5 f) % pow2 128 == v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104))
let lemma_tup64_mod_pow2_128 f =
let (f0, f1, f2, f3, f4) = f in
let tmp = v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 in
calc (==) {
(as_nat5 f) % pow2 128;
(==) { }
(v f0 + v f1 * pow26 + v f2 * pow52 + v f3 * pow78 + v f4 * pow104) % pow2 128;
(==) { FStar.Math.Lemmas.lemma_mod_plus_distr_r tmp (v f4 * pow104) (pow2 128) }
(tmp + (v f4 * pow104 % pow2 128)) % pow2 128;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 128 104 }
(tmp + (v f4 % pow2 24) * pow104) % pow2 128;
(==) { lemma_tup64_pow2_128 f; FStar.Math.Lemmas.modulo_lemma (tmp + (v f4 % pow2 24) * pow104) (pow2 128) }
tmp + (v f4 % pow2 24) * pow104;
};
assert ((as_nat5 f) % pow2 128 == tmp + (v f4 % pow2 24) * pow104)
noextract
val store_tup64_lemma: f:tup64_5 ->
Pure (uint64 & uint64)
(requires tup64_fits5 f (1, 1, 1, 1, 1))
(ensures (fun (lo, hi) -> v hi * pow2 64 + v lo == as_nat5 f % pow2 128))
let store_tup64_lemma f =
let (f0, f1, f2, f3, f4) = f in
let lo = f0 |. (f1 <<. 26ul) |. (f2 <<. 52ul) in
let hi = (f2 >>. 12ul) |. (f3 <<. 14ul) |. (f4 <<. 40ul) in
lemma_store_felem_lo f lo;
lemma_store_felem_hi f hi;
assert (v lo == v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64);
assert (v hi == v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64);
calc (==) {
v lo + v hi * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
(v f2 / pow2 12 + v f3 * pow2 14 + (v f4 * pow2 40) % pow2 64) * pow2 64;
(==) { }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 * pow2 40) % pow2 64 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 40 }
v f0 + v f1 * pow2 26 + (v f2 * pow2 52) % pow2 64 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 52 }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow2 40 * pow2 64;
(==) { assert_norm (pow2 40 * pow2 64 = pow104) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow2 14 * pow2 64 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 14 * pow2 64 = pow78) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12) * pow2 52 +
v f2 / pow2 12 * pow2 64 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { assert_norm (pow2 12 * pow52 = pow2 64) }
v f0 + v f1 * pow2 26 + (v f2 % pow2 12 + v f2 / pow2 12 * pow2 12) * pow52 +
v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 12) }
v f0 + v f1 * pow2 26 + v f2 * pow52 + v f3 * pow78 + (v f4 % pow2 24) * pow104;
(==) { lemma_tup64_mod_pow2_128 f }
(as_nat5 f) % pow2 128;
};
assert (v lo + v hi * pow2 64 == (as_nat5 f) % pow2 128);
lo, hi
#push-options "--max_ifuel 1"
val store_felem5_lemma:
#w:lanes
-> f:felem5 w ->
Lemma
(requires felem_fits5 f (1, 1, 1, 1, 1))
(ensures
(let (lo, hi) = store_felem5 f in
v hi * pow2 64 + v lo == (fas_nat5 f).[0] % pow2 128))
let store_felem5_lemma #w f =
let (lo, hi) = store_felem5 f in
assert (store_tup64_lemma (as_tup64_i f 0) == (lo, hi))
#pop-options
val lemma_sum_lt_pow2_26: i:nat -> a:nat{a < pow2 (i % 26)} -> b:nat{b <= pow2 (i % 26)} ->
Lemma (a + b <= max26)
let lemma_sum_lt_pow2_26 i a b =
assert (a + b < pow2 (i % 26) + pow2 (i % 26));
FStar.Math.Lemmas.pow2_le_compat 25 (i % 26);
assert (a + b < pow2 25 + pow2 25);
FStar.Math.Lemmas.pow2_double_sum 25;
assert_norm (pow26 = pow2 26)
val lset_bit5_lemma_aux: fi:uint64 -> i:size_nat{i <= 128} ->
Lemma
(requires v fi < pow2 (i % 26))
(ensures (v (fi |. (u64 1 <<. size (i % 26))) == v fi + pow2 (i % 26)))
let lset_bit5_lemma_aux fi i =
let b = u64 1 <<. size (i % 26) in
FStar.Math.Lemmas.pow2_lt_compat 26 (i % 26);
FStar.Math.Lemmas.pow2_lt_compat 64 26;
FStar.Math.Lemmas.modulo_lemma (pow2 (i % 26)) (pow2 64);
assert (v b == pow2 (i % 26));
logor_disjoint fi b (i % 26);
let out_i = fi |. b in
assert (v out_i == v fi + v b);
assert (v out_i == v fi + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v fi) (v b);
assert_norm (pow26 = pow2 26);
assert (v out_i <= max26)
val lset_bit5_lemma0:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 0} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma0 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[0] <- f.[0] |. b in
assert (v f.[i / 26] < pow2 (i % 26));
lset_bit5_lemma_aux f.[0] i;
assert (v out.[0] == v f.[0] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[0]) (pow2 (i % 26));
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma1:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 1} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma1 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[1] <- f.[1] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f1 * pow2 26 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f1 * pow2 26) i 26;
assert (v f1 < pow2 (i - 26));
assert (i - 26 == i % 26);
assert (v f.[1] < pow2 (i % 26));
lset_bit5_lemma_aux f.[1] i;
assert (v out.[1] == v f.[1] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[1]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow26 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 26 }
pow2 (i % 26 + 26) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma2:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 2} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4])))
let lset_bit5_lemma2 f i =
let b = u64 1 <<. size (i % 26) in
let out = f.[2] <- f.[2] |. b in
let (f0, f1, f2, f3, f4) = (f.[0], f.[1], f.[2], f.[3], f.[4]) in
let (o0, o1, o2, o3, o4) = (out.[0], out.[1], out.[2], out.[3], out.[4]) in
assert (v f2 * pow52 < pow2 i);
FStar.Math.Lemmas.lemma_div_lt_nat (v f2 * pow52) i 52;
assert (v f2 < pow2 (i - 52));
assert (i - 52 == i % 26);
assert (v f.[2] < pow2 (i % 26));
lset_bit5_lemma_aux f.[2] i;
assert (v out.[2] == v f.[2] + pow2 (i % 26));
lemma_sum_lt_pow2_26 i (v f.[2]) (pow2 (i % 26));
calc (==) {
as_nat5 (o0, o1, o2, o3, o4);
(==) { }
v o0 + v o1 * pow26 + v o2 * pow52 + v o3 * pow78 + v o4 * pow104;
(==) { }
pow2 (i % 26) * pow52 + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.pow2_plus (i % 26) 52 }
pow2 (i % 26 + 52) + as_nat5 (f0, f1, f2, f3, f4);
(==) { FStar.Math.Lemmas.euclidean_division_definition i 26 }
pow2 i + as_nat5 (f0, f1, f2, f3, f4);
};
assert (as_nat5 (o0, o1, o2, o3, o4) == pow2 i + as_nat5 (f0, f1, f2, f3, f4))
val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | false | false | Hacl.Poly1305.Field32xN.Lemmas2.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lset_bit5_lemma3:
f:lseq uint64 5
-> i:size_nat{i <= 128 /\ i / 26 = 3} ->
Lemma
(requires
(forall (i:nat). i < 5 ==> v f.[i] <= max26) /\
as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]) < pow2 i)
(ensures
(let b = u64 1 <<. size (i % 26) in
let out = f.[i / 26] <- f.[i / 26] |. b in
(forall (i:nat). i < 5 ==> v out.[i] <= max26) /\
as_nat5 (out.[0], out.[1], out.[2], out.[3], out.[4]) ==
pow2 i + as_nat5 (f.[0], f.[1], f.[2], f.[3], f.[4]))) | [] | Hacl.Poly1305.Field32xN.Lemmas2.lset_bit5_lemma3 | {
"file_name": "code/poly1305/Hacl.Poly1305.Field32xN.Lemmas2.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> i: Lib.IntTypes.size_nat{i <= 128 /\ i / 26 = 3}
-> FStar.Pervasives.Lemma
(requires
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v f.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]) <
Prims.pow2 i)
(ensures
(let b = Lib.IntTypes.u64 1 <<. Lib.IntTypes.size (i % 26) in
let out = f.[ i / 26 ] <- f.[ i / 26 ] |. b in
(forall (i: Prims.nat).
i < 5 ==> Lib.IntTypes.v out.[ i ] <= Hacl.Spec.Poly1305.Field32xN.max26) /\
Hacl.Spec.Poly1305.Field32xN.as_nat5 (out.[ 0 ],
out.[ 1 ],
out.[ 2 ],
out.[ 3 ],
out.[ 4 ]) ==
Prims.pow2 i +
Hacl.Spec.Poly1305.Field32xN.as_nat5 (f.[ 0 ], f.[ 1 ], f.[ 2 ], f.[ 3 ], f.[ 4 ]))) | {
"end_col": 80,
"end_line": 710,
"start_col": 26,
"start_line": 685
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.