file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_at_least | val i_at_least : n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 117,
"start_col": 0,
"start_line": 115
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows_p",
"Prims.eq2",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | false | false | false | false | true | let i_at_least (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p) (h: mem) =
| Seq.length (HS.sel h m) > n /\ Seq.index (HS.sel h m) n == x | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.op_At | val op_At : s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | let op_At s1 s2 = Seq.append s1 s2 | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 210,
"start_col": 8,
"start_line": 210
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append"
] | [] | false | false | false | true | false | let ( @ ) s1 s2 =
| Seq.append s1 s2 | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_prefix | val map_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 269,
"start_col": 0,
"start_line": 264
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.map",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | false | false | false | true | let map_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
(h: mem)
=
| grows bs (map f (HS.sel h r)) | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.alloc_mref_seq | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 68,
"start_col": 0,
"start_line": 61
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | r: FStar.Monotonic.Seq.rid -> init: FStar.Seq.Base.seq a
-> FStar.HyperStack.ST.ST
(FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mref",
"FStar.HyperStack.ST.m_rref",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel",
"FStar.HyperStack.ST.ralloc_post"
] | [] | false | true | false | false | false | let alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) =
| ralloc r init | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_at_least_is_stable | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 121,
"start_col": 0,
"start_line": 119
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t m (FStar.Monotonic.Seq.i_at_least n x m)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_prefix | val collect_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 332,
"start_col": 0,
"start_line": 327
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | false | false | false | true | let collect_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
(h: mem)
=
| grows bs (collect f (HS.sel h r)) | false |
|
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_mul_st | val bn_almost_mont_mul_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_almost_mont_mul_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> bM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM bM /\
eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM)) | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 52,
"start_col": 0,
"start_line": 40
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication
inline_for_extraction noextract
let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c))
inline_for_extraction noextract
val bn_almost_mont_reduction: #t:limb_t -> k:BN.bn t -> bn_almost_mont_reduction_st t k.BN.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.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.Bignum.AlmostMontgomery.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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": "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": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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": "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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_mul"
] | [] | false | false | false | false | true | let bn_almost_mont_mul_st (t: limb_t) (len: BN.meta_len t) =
| n: lbignum t len -> mu: limb t -> aM: lbignum t len -> bM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\ disjoint resM n /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM)) | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_has_at_index | val collect_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 353,
"start_col": 0,
"start_line": 347
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.Seq.collect",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Monotonic.HyperStack.sel",
"Prims.logical"
] | [] | false | false | false | false | true | let collect_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
(h: mem)
=
| let s = HS.sel h r in
n < Seq.length (collect f s) /\ Seq.index (collect f s) n == v | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.int_at_most_is_stable | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 128,
"start_col": 0,
"start_line": 126
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | is: FStar.Monotonic.Seq.i_seq r a p -> k: Prims.int
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t is (FStar.Monotonic.Seq.int_at_most k is)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.i_seq",
"Prims.int",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.int_at_most",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_least_is_stable | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 79,
"start_col": 0,
"start_line": 77
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
n: Prims.nat ->
x: a ->
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.at_least n x r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_least",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_read | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 138,
"start_col": 0,
"start_line": 134
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | m: FStar.Monotonic.Seq.i_seq r a p -> FStar.HyperStack.ST.ST (s: FStar.Seq.Base.seq a {p s}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.squash",
"FStar.Monotonic.Seq.i_sel"
] | [] | false | true | false | false | false | let i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) =
| !m | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.grows_p | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2 | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 105,
"start_col": 0,
"start_line": 104
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
//////////////////////////////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | p: (_: FStar.Seq.Base.seq a -> Type) -> FStar.Preorder.preorder (s: FStar.Seq.Base.seq a {p s}) | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Preorder.preorder"
] | [] | false | false | false | false | false | let grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) =
| fun s1 s2 -> grows s1 s2 | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.invariant | val invariant : s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 167,
"start_col": 8,
"start_line": 165
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_disEquality",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | false | false | false | true | true | let invariant (s: seq nat) =
| forall (i: nat) (j: nat).
i < Seq.length s /\ j < Seq.length s /\ i <> j ==> Seq.index s i <> Seq.index s j | false |
|
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_reduction_st | val bn_almost_mont_reduction_st : t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c)) | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 32,
"start_col": 0,
"start_line": 22
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.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.Bignum.AlmostMontgomery.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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": "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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Lib.IntTypes.op_Plus_Bang",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_reduction"
] | [] | false | false | false | false | true | let bn_almost_mont_reduction_st (t: limb_t) (len: size_t{0 < v len /\ v len + v len <= max_size_t}) =
| n: lbignum t len -> mu: limb t -> c: lbignum t (len +! len) -> res: lbignum t len
-> Stack unit
(requires
fun h ->
live h n /\ live h c /\ live h res /\ disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures
fun h0 _ h1 ->
modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c)) | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.write_at_end | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) | let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 98,
"start_col": 0,
"start_line": 82
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows -> x: a
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.at_least_is_stable",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Seq.Properties.snoc",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"FStar.Monotonic.HyperStack.contains",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel",
"FStar.HyperStack.ST.witnessed"
] | [] | false | true | false | false | false | let write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.sel h0 r) x /\
witnessed (at_least (Seq.length (HS.sel h0 r)) x r))) =
| recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.test0 | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 178,
"start_col": 0,
"start_line": 172
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.Monotonic.Seq.rid ->
a: FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq Prims.nat) FStar.Monotonic.Seq.grows ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"FStar.Seq.Properties.contains_intro",
"FStar.Monotonic.Seq.at_least_is_stable",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let test0 r a k =
| let h0 = HST.get () in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k)
in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.itest | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 186,
"start_col": 0,
"start_line": 183
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.Monotonic.Seq.rid ->
a: FStar.Monotonic.Seq.i_seq r Prims.nat FStar.Monotonic.Seq.invariant ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"Prims.nat",
"FStar.Monotonic.Seq.invariant",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.i_sel",
"Prims.unit",
"FStar.Monotonic.Seq.i_at_least_is_stable",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | true | false | false | false | let itest r a k =
| let h0 = HST.get () in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 202,
"start_col": 0,
"start_line": 199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | false | true | false | let rec map f s =
| if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_write_at_end | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) | let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 160,
"start_col": 0,
"start_line": 144
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | r: FStar.Monotonic.Seq.i_seq rgn a p -> x: a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.i_at_least_is_stable",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Seq.Properties.snoc",
"Prims.nat",
"FStar.Seq.Base.length",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.i_sel",
"Prims.l_and",
"FStar.Monotonic.Seq.i_contains",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.eq2",
"FStar.HyperStack.ST.witnessed"
] | [] | false | true | false | false | false | let i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1 /\
i_sel h1 r == Seq.snoc (i_sel h0 r) x /\
witnessed (i_at_least (Seq.length (i_sel h0 r)) x r))) =
| recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_most_log_len | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 372,
"start_col": 0,
"start_line": 370
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a -> _: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.HyperStack.mem",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows"
] | [] | false | false | false | false | true | let at_most_log_len (#l: rid) (#a: Type) (x: nat) (log: log_t l a) : mem -> GTot Type0 =
| fun h -> x <= Seq.length (HS.sel h log) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.increases | val increases : x: Prims.int -> y: Prims.int -> Prims.logical | let increases (x:int) (y:int) = b2t (x <= y) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 368,
"start_col": 0,
"start_line": 368
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | x: Prims.int -> y: Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.logical"
] | [] | false | false | false | true | true | let increases (x y: int) =
| b2t (x <= y) | false |
|
Hacl.Impl.Ed25519.Sign.fst | Hacl.Impl.Ed25519.Sign.sign_compute_s | val sign_compute_s (r hs:lbuffer uint64 5ul) (a s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h r /\ live h hs /\ live h a /\ live h s /\
disjoint s r /\ disjoint s hs /\ disjoint s a /\
F56.scalar_inv_full_t h r /\ F56.scalar_inv_full_t h hs)
(ensures fun h0 _ h1 -> modifies (loc s) h0 h1 /\
as_seq h1 s == BSeq.nat_to_bytes_le 32 ((F56.as_nat h0 r +
(F56.as_nat h0 hs * BSeq.nat_from_bytes_le (as_seq h0 a)) % Spec.Ed25519.q) % Spec.Ed25519.q)) | val sign_compute_s (r hs:lbuffer uint64 5ul) (a s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h r /\ live h hs /\ live h a /\ live h s /\
disjoint s r /\ disjoint s hs /\ disjoint s a /\
F56.scalar_inv_full_t h r /\ F56.scalar_inv_full_t h hs)
(ensures fun h0 _ h1 -> modifies (loc s) h0 h1 /\
as_seq h1 s == BSeq.nat_to_bytes_le 32 ((F56.as_nat h0 r +
(F56.as_nat h0 hs * BSeq.nat_from_bytes_le (as_seq h0 a)) % Spec.Ed25519.q) % Spec.Ed25519.q)) | let sign_compute_s r hs a s =
push_frame ();
let aq = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes aq a;
Hacl.Impl.BignumQ.Mul.mul_modq aq hs aq;
Hacl.Impl.BignumQ.Mul.add_modq aq r aq;
assert_norm (0x100000000000000 == pow2 56);
Hacl.Impl.Store56.store_56 s aq;
pop_frame () | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 53,
"start_col": 0,
"start_line": 45
} | module Hacl.Impl.Ed25519.Sign
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.BignumQ.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s)))
[@CInline]
let point_mul_g_compress out s =
push_frame ();
let tmp = create 20ul (u64 0) in
Hacl.Impl.Ed25519.Ladder.point_mul_g tmp s;
Hacl.Impl.Ed25519.PointCompress.point_compress out tmp;
pop_frame ()
inline_for_extraction noextract
val sign_compute_s (r hs:lbuffer uint64 5ul) (a s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h r /\ live h hs /\ live h a /\ live h s /\
disjoint s r /\ disjoint s hs /\ disjoint s a /\
F56.scalar_inv_full_t h r /\ F56.scalar_inv_full_t h hs)
(ensures fun h0 _ h1 -> modifies (loc s) h0 h1 /\
as_seq h1 s == BSeq.nat_to_bytes_le 32 ((F56.as_nat h0 r +
(F56.as_nat h0 hs * BSeq.nat_from_bytes_le (as_seq h0 a)) % Spec.Ed25519.q) % Spec.Ed25519.q)) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.Store56.fst.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointCompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Impl.BignumQ.Mul.fsti.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.Impl.Ed25519.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"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.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
r: Lib.Buffer.lbuffer Lib.IntTypes.uint64 5ul ->
hs: Lib.Buffer.lbuffer Lib.IntTypes.uint64 5ul ->
a: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint8",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Store56.store_56",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.pow2",
"Hacl.Impl.BignumQ.Mul.add_modq",
"Hacl.Impl.BignumQ.Mul.mul_modq",
"Hacl.Impl.Load56.load_32_bytes",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let sign_compute_s r hs a s =
| push_frame ();
let aq = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes aq a;
Hacl.Impl.BignumQ.Mul.mul_modq aq hs aq;
Hacl.Impl.BignumQ.Mul.add_modq aq r aq;
assert_norm (0x100000000000000 == pow2 56);
Hacl.Impl.Store56.store_56 s aq;
pop_frame () | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_length | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 242,
"start_col": 0,
"start_line": 239
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.length s1 = FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))
(decreases FStar.Seq.Base.length s1)
[SMTPat (FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))] | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Monotonic.Seq.map_length",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | true | false | false | let rec map_length f s1 =
| if Seq.length s1 = 0
then ()
else
let prefix, last = un_snoc s1 in
map_length f prefix | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_append | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 230,
"start_col": 0,
"start_line": 217
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (s1 @ s2) ==
FStar.Monotonic.Seq.map f s1 @ FStar.Monotonic.Seq.map f s2)
(decreases FStar.Seq.Base.length s2) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Monotonic.Seq.op_At",
"FStar.Monotonic.Seq.map",
"Prims.unit",
"Prims.bool",
"FStar.Monotonic.Seq.map_snoc",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map_append",
"FStar.Seq.Base.append",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | true | false | false | let rec map_append f s_1 s_2 =
| if Seq.length s_2 = 0
then
(cut (Seq.equal (s_1 @ s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else
(let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1 @ s_2) (Seq.snoc (s_1 @ prefix_2) last));
map_snoc f (Seq.append s_1 prefix_2) last;
map_append f s_1 prefix_2;
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast) (m_s_1 @ Seq.snoc m_p_2 flast));
map_snoc f prefix_2 last) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.un_snoc | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 195,
"start_col": 0,
"start_line": 193
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
//////////////////////////////////////////////////////////////////////////////// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq a * a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.index",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let un_snoc #a s =
| let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_has_at_index | val map_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 283,
"start_col": 0,
"start_line": 277
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.map",
"FStar.Monotonic.HyperStack.sel",
"Prims.logical"
] | [] | false | false | false | false | true | let map_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
(h: mem)
=
| let s = HS.sel h r in
n < Seq.length s /\ Seq.index (map f s) n == v | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_grows | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 262,
"start_col": 0,
"start_line": 257
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties! | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: a -> b) -> s1: FStar.Seq.Base.seq a -> s3: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s3 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.map f s1) (FStar.Monotonic.Seq.map f s3)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"FStar.Monotonic.Seq.map",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) =
| reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | false |
Hacl.Impl.Ed25519.Sign.fst | Hacl.Impl.Ed25519.Sign.point_mul_g_compress | val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s))) | val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s))) | let point_mul_g_compress out s =
push_frame ();
let tmp = create 20ul (u64 0) in
Hacl.Impl.Ed25519.Ladder.point_mul_g tmp s;
Hacl.Impl.Ed25519.PointCompress.point_compress out tmp;
pop_frame () | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 32,
"start_col": 0,
"start_line": 27
} | module Hacl.Impl.Ed25519.Sign
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.BignumQ.Definitions
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s))) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.Store56.fst.checked",
"Hacl.Impl.SHA512.ModQ.fst.checked",
"Hacl.Impl.Load56.fst.checked",
"Hacl.Impl.Ed25519.PointCompress.fst.checked",
"Hacl.Impl.Ed25519.Ladder.fsti.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Impl.BignumQ.Mul.fsti.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.Impl.Ed25519.Sign.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"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.Impl.Ed25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Ed25519",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | out: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Ed25519.PointCompress.point_compress",
"Hacl.Impl.Ed25519.Ladder.point_mul_g",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let point_mul_g_compress out s =
| push_frame ();
let tmp = create 20ul (u64 0) in
Hacl.Impl.Ed25519.Ladder.point_mul_g tmp s;
Hacl.Impl.Ed25519.PointCompress.point_compress out tmp;
pop_frame () | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_prefix_stable | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 345,
"start_col": 0,
"start_line": 334
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_prefix r f bs)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Classical.forall_intro_2",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"Prims.l_and",
"FStar.Monotonic.Seq.collect_prefix",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"FStar.Monotonic.Seq.collect_grows",
"FStar.HyperStack.ST.stable_on_t"
] | [] | false | false | true | false | false | let collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) =
| let aux: h0: mem -> h1: mem
-> Lemma
(collect_prefix r f bs h0 /\ grows (HS.sel h0 r) (HS.sel h1 r) ==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_index | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 253,
"start_col": 0,
"start_line": 249
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.index (FStar.Monotonic.Seq.map f s) i == f (FStar.Seq.Base.index s i))
(decreases FStar.Seq.Base.length s)
[SMTPat (FStar.Seq.Base.index (FStar.Monotonic.Seq.map f s) i)] | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.bool",
"FStar.Monotonic.Seq.map_index",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | true | false | false | let rec map_index f s i =
| if i = Seq.length s - 1
then ()
else
let prefix, last = un_snoc s in
map_index f prefix i | false |
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_sqr_st | val bn_almost_mont_sqr_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_almost_mont_sqr_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_sqr (as_seq h0 n) mu (as_seq h0 aM)) | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 74,
"start_col": 0,
"start_line": 64
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
/// Almost Montgomery Multiplication
inline_for_extraction noextract
let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
as_seq h1 res == S.bn_almost_mont_reduction (as_seq h0 n) mu (as_seq h0 c))
inline_for_extraction noextract
val bn_almost_mont_reduction: #t:limb_t -> k:BN.bn t -> bn_almost_mont_reduction_st t k.BN.len
inline_for_extraction noextract
let bn_almost_mont_mul_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> bM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM bM /\
eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_mul (as_seq h0 n) mu (as_seq h0 aM) (as_seq h0 bM))
inline_for_extraction noextract
val bn_almost_mont_mul:
#t:limb_t
-> k:BN.bn t
-> mr:bn_almost_mont_reduction_st t k.BN.len ->
bn_almost_mont_mul_st t k.BN.len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tactics.Typeclasses.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.Bignum.AlmostMontgomery.fsti"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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": "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": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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": "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.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Lib.Sequence.lseq",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.Buffer.as_seq",
"Hacl.Spec.Bignum.AlmostMontgomery.bn_almost_mont_sqr"
] | [] | false | false | false | false | true | let bn_almost_mont_sqr_st (t: limb_t) (len: BN.meta_len t) =
| n: lbignum t len -> mu: limb t -> aM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h -> live h aM /\ live h resM /\ live h n /\ disjoint resM n /\ eq_or_disjoint aM resM)
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_almost_mont_sqr (as_seq h0 n) mu (as_seq h0 aM)) | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 302,
"start_col": 0,
"start_line": 299
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Monotonic.Seq.collect",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | false | true | false | let rec collect f s =
| if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_has_at_index_stable | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 289,
"start_col": 0,
"start_line": 285
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_has_at_index r f n v)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_has_at_index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_grows | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 118,
"end_line": 325,
"start_col": 0,
"start_line": 312
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s2 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.collect f s1)
(FStar.Monotonic.Seq.collect f s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Classical.arrow_to_impl",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.collect",
"Prims.squash",
"Prims.unit",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_Equality",
"Prims.nat",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.bool",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.l_True",
"Prims.l_imp"
] | [] | false | false | true | false | false | let collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) =
| reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (requires (grows s1 s2))
(ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2)) =
if length s1 = length s2
then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2)
#(grows (collect f s1) (collect f s2))
(fun _ -> collect_grows_aux f s1 s2) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_snoc | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 208,
"start_col": 0,
"start_line": 206
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Properties.snoc (FStar.Monotonic.Seq.map f s) (f a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | false | false | true | false | false | let map_snoc f s a =
| let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_prefix_stable | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 275,
"start_col": 0,
"start_line": 272
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_prefix r f bs)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_prefix",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) =
| reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_snoc | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 308,
"start_col": 0,
"start_line": 306
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"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"
} | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.collect f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Base.append (FStar.Monotonic.Seq.collect f s) (f a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | false | false | true | false | false | let collect_snoc f s a =
| let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_has_at_index_stable | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 360,
"start_col": 0,
"start_line": 355
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_has_at_index r f n v)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.Seq.collect_grows",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.collect_has_at_index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) =
| reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_most_log_len_stable | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 386,
"start_col": 0,
"start_line": 384
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t log (FStar.Monotonic.Seq.at_most_log_len x log)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.testify_seqn | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\
at_most_log_len (HS.sel h1 ctr) log h1))
= let n = !ctr in
testify (at_most_log_len n log) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 431,
"start_col": 0,
"start_line": 424
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init
let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | ctr: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"Prims.nat",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.testify",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.unit",
"FStar.Monotonic.Seq.seqn_val",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | true | false | false | false | let testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) =
| let n = !ctr in
testify (at_most_log_len n log) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.test | val test : i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | let test (i:rid) (l:rid) (a:Type0) (log:log_t l a) //(p:(nat -> Type))
(r:seqn i log 8) (h:mem)
= assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 435,
"start_col": 8,
"start_line": 433
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init
let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n
let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\
at_most_log_len (HS.sel h1 ctr) log h1))
= let n = !ctr in
testify (at_most_log_len n log) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.Monotonic.HyperStack.mem",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.Heap.sel",
"FStar.Map.sel",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap",
"FStar.Monotonic.HyperStack.as_ref",
"Prims.unit"
] | [] | false | false | false | false | false | let test (i l: rid) (a: Type0) (log: log_t l a) (r: seqn i log 8) (h: mem) =
| assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | false |
|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.increment_seqn | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) | let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1))
= reveal_opaque (`%grows) (grows #a);
recall c; recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 422,
"start_col": 0,
"start_line": 406
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a)
let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | $c: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.int",
"Prims.op_Addition",
"FStar.HyperStack.ST.op_Bang",
"FStar.HyperStack.ST.recall",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_LessThanOrEqual",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.singleton",
"FStar.Monotonic.HyperStack.as_addr",
"Prims.op_Equality"
] | [] | false | true | false | false | false | let increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
modifies_one i h0 h1 /\ modifies_ref i (Set.singleton (HS.as_addr c)) h0 h1 /\
HS.sel h1 c = HS.sel h0 c + 1)) =
| reveal_opaque (`%grows) (grows #a);
recall c;
recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_bytes | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64 | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ] | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_bytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64"
] | [] | false | false | false | false | false | let crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} =
| crypto_bytes FP.Frodo64 | false |
Steel.HigherReference.fsti | Steel.HigherReference.ghost_pts_to | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | let ghost_pts_to (#a:_) (r:ghost_ref a) (p:perm) (x:a) : vprop =
to_vprop (ghost_pts_to_sl r p x) | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 212,
"start_col": 7,
"start_line": 211
} | (*
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 Steel.HigherReference
open Steel.FractionalPermission
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
/// A library for Steel references with fractional permissions, storing values at universe 1
/// Under the hood, this library builds upon the PCM-based reference memory model in
/// Steel.PCMReference, by instantiating a specific fractional permission PCM
/// An abstract datatype for references
val ref ([@@@unused] a:Type u#1) : Type u#0
/// The null pointer
val null (#a:Type u#1) : ref a
/// Checking whether a pointer is null can be done in a decidable way
val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null})
/// The standard points to separation logic assertion, expressing that
/// reference [r] is valid in memory, stores value [v], and that we have
/// permission [p] on it.
val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector
[@@ __steel_reduce__]
unfold let pts_to (#a:Type u#1) (r:ref a) (p:perm) (v:a) : vprop =
to_vprop (pts_to_sl r p v)
/// If two pts_to predicates on the same reference [r] are valid in the memory [m],
/// then the two values [v0] and [v1] are identical
val pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
/// A valid pts_to predicate implies that the pointer is not the null pointer
val pts_to_not_null (#a:Type u#1)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
/// Exposing the is_witness_invariant from Steel.Memory for HigherReferences
val pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p))
/// A stateful version of the pts_to_ref_injective lemma above
val higher_ref_pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
/// A permission is always no greater than one
val pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ref a)
: SteelGhost unit u
(pts_to r p v)
(fun _ -> pts_to r p v)
(fun _ -> True)
(fun _ _ _ -> p `lesser_equal_perm` full_perm)
/// Allocates a reference with value [x]. We have full permission on the newly
/// allocated reference.
val alloc (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r))
/// Reads the value in reference [r], as long as it initially is valid
val read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
/// Atomic read
///
/// -- This is a little too powerful. We should only allow it on [t]'s
/// that are small enough. E.g., word-sized
val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a)
(r:ref a)
: SteelAtomic a opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
/// A variant of read, useful when an existentially quantified predicate
/// depends on the value stored in the reference
val read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v)
/// Writes value [x] in the reference [r], as long as we have full ownership of [r]
val write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
/// Atomic write, also requires full ownership of [r]
///
/// -- This is a little too powerful. We should only allow it on [t]'s
/// that are small enough. E.g., word-sized
val atomic_write (#opened:_) (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelAtomicT unit opened (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
/// Frees reference [r], as long as we have full ownership of [r]
val free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp)
/// Splits the permission on reference [r] into two.
/// This function is computationally irrelevant (it has effect SteelGhost)
val share_gen (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ref a)
(p1 p2: perm)
: SteelGhost unit u
(pts_to r p x)
(fun _ -> pts_to r p1 x `star`
pts_to r p2 x)
(fun _ -> p == p1 `sum_perm` p2)
(fun _ _ _ -> True)
val share (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
/// Combines permissions on reference [r].
/// This function is computationally irrelevant (it has effect SteelGhost)
val gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r (sum_perm p0 p1) v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
/// Implementing cas as an action on references.
val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
(*** Ghost references ***)
/// We also define a ghost variant of references, useful to do proofs relying on a ghost state
/// Ghost references are marked as erasable, ensuring that they are computationally irrelevant,
/// and only used in computationally irrelevant contexts.
/// The functions below are variants of the reference functions defined above,
/// but operating on ghost references, and with the computationally irrelevant SteelGhost effect
[@@ erasable]
val ghost_ref (a:Type u#1) : Type u#0
val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1
/// Lemmas to break the abstraction, if one needs to manipulate both
/// ghost and non-ghost references. These lemmas have no SMT patterns
/// so that the normalizer or SMT won't silently unfold the
/// definitions of ghost_ref or ghost_pts_to_sl. These should be
/// harmless since ghost_ref is erasable
val reveal_ghost_ref (a: Type u#1) : Lemma
(ghost_ref a == erased (ref a))
val reveal_ghost_pts_to_sl
(#a: _) (r: ghost_ref a) (p: perm) (x: a)
: Lemma
(ghost_pts_to_sl r p x == pts_to_sl (reveal (coerce_eq (reveal_ghost_ref a) r)) p x) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.HigherReference.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"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
}
] | {
"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"
} | false | r: Steel.HigherReference.ghost_ref a -> p: Steel.FractionalPermission.perm -> x: a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.HigherReference.ghost_ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.ghost_pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | true | false | let ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop =
| to_vprop (ghost_pts_to_sl r p x) | false |
Steel.HigherReference.fsti | Steel.HigherReference.pts_to | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | let pts_to (#a:Type u#1) (r:ref a) (p:perm) (v:a) : vprop =
to_vprop (pts_to_sl r p v) | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 28,
"end_line": 49,
"start_col": 7,
"start_line": 48
} | (*
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 Steel.HigherReference
open Steel.FractionalPermission
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
module Mem = Steel.Memory
/// A library for Steel references with fractional permissions, storing values at universe 1
/// Under the hood, this library builds upon the PCM-based reference memory model in
/// Steel.PCMReference, by instantiating a specific fractional permission PCM
/// An abstract datatype for references
val ref ([@@@unused] a:Type u#1) : Type u#0
/// The null pointer
val null (#a:Type u#1) : ref a
/// Checking whether a pointer is null can be done in a decidable way
val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null})
/// The standard points to separation logic assertion, expressing that
/// reference [r] is valid in memory, stores value [v], and that we have
/// permission [p] on it.
val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1
/// Lifting the standard points to predicate to vprop, with a non-informative selector | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.HigherReference.fsti"
} | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"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
}
] | {
"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"
} | false | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | true | false | let pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop =
| to_vprop (pts_to_sl r p v) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.new_seqn | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) | let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
modifies_one i h0 h1 /\
modifies_ref i Set.empty h0 h1 /\
fresh_ref c h0 h1 /\
HS.sel h1 c = init /\
FStar.Map.contains (HS.get_hmap h1) i))
= reveal_opaque (`%grows) (grows #a);
recall log; recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 404,
"start_col": 0,
"start_line": 388
} | (*
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.Monotonic.Seq
open FStar.Seq
open FStar.Classical
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
open FStar.HyperStack
open FStar.HyperStack.ST
(* 2016-11-22: The following is meant to override the fact that the
enclosing namespace of the current module (here FStar.Monotonic) is
automatically opened, which makes Seq resolve into
FStar.Monotonic.Seq instead of FStar.Seq. *)
module Seq = FStar.Seq
////////////////////////////////////////////////////////////////////////////////
(*
* 12/08
* AR: writing this in terms of length and index
* earlier it was written in terms of an exists s3. Seq.equal (append s1 s3) s2
* that meant going through many hoops to prove simple things like transitivity of grows
* so far this seems to work better.
*)
let grows_aux (#a:Type) :Preorder.preorder (seq a)
= fun (s1:seq a) (s2:seq a) ->
length s1 <= length s2 /\
(forall (i:nat).{:pattern (Seq.index s1 i) \/ (Seq.index s2 i)} i < length s1 ==> index s1 i == index s2 i)
[@@"opaque_to_smt"]
let grows #a = grows_aux #a
type rid = HST.erid
let snoc (s:seq 'a) (x:'a)
: Tot (seq 'a)
= Seq.append s (Seq.create 1 x)
let lemma_snoc_extends (#a:Type) (s:seq a) (x:a)
: Lemma (requires True)
(ensures (grows s (Seq.snoc s x)))
[SMTPat (grows s (Seq.snoc s x))]
= reveal_opaque (`%grows) (grows #a)
let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init
(*
* AR: changing rids below to rid which is eternal regions.
*)
let at_least (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows) (h:mem) =
Seq.length (HS.sel h r) > n
/\ Seq.index (HS.sel h r) n == x
let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a)
(** extending a stored sequence, witnessing its new entry for convenience. *)
let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
/\ witnessed (at_least (Seq.length (HS.sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Monotone sequences with a (stateless) invariant of the whole sequence
////////////////////////////////////////////////////////////////////////////////
let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2
let i_seq (r:rid) (a:Type) (p:seq a -> Type) = m_rref r (s:seq a{p s}) (grows_p p)
let alloc_mref_iseq (#a:Type) (p:seq a -> Type) (r:rid) (init:seq a{p init})
: ST (i_seq r a p)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 -> HST.ralloc_post r init h0 m h1))
= ralloc r init
let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x
let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a)
let int_at_most #r #a #p (x:int) (is:i_seq r a p) (h:mem) : Type0 =
x < Seq.length (HS.sel h is)
let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a)
let i_sel (#r:rid) (#a:Type) (#p:seq a -> Type) (h:mem) (m:i_seq r a p)
: GTot (s:seq a{p s})
= HS.sel h m
let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m
let i_contains (#r:rid) (#a:Type) (#p:seq a -> Type) (m:i_seq r a p) (h:mem)
: GTot Type0
= HS.contains h m
let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/\ i_sel h1 r == Seq.snoc (i_sel h0 r) x
/\ witnessed (i_at_least (Seq.length (i_sel h0 r)) x r)))
=
recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r)
////////////////////////////////////////////////////////////////////////////////
//Testing invariant sequences
////////////////////////////////////////////////////////////////////////////////
private let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j
private val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True))
let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a)
private val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True))
let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a)
////////////////////////////////////////////////////////////////////////////////
//Mapping functions over monotone sequences
////////////////////////////////////////////////////////////////////////////////
val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a)
let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last
val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last)
val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a))
let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
private let op_At s1 s2 = Seq.append s1 s2
val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2))
#reset-options "--z3rlimit 10 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (Seq.snoc (s_1@prefix_2) last)); //map f (s1@s2) = map f (snoc (s1@p) last)
map_snoc f (Seq.append s_1 prefix_2) last; // = snoc (map f (s1@p)) (f last)
map_append f s_1 prefix_2; // = snoc (map f s_1 @ map f p) (f last)
cut (Seq.equal (Seq.snoc (m_s_1 @ m_p_2) flast)
(m_s_1 @ Seq.snoc m_p_2 flast)); // = map f s1 @ (snoc (map f p) (f last))
map_snoc f prefix_2 last) // = map f s1 @ map f (snoc p last)
#reset-options "--z3rlimit 5"
val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))]
let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix
val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)]
let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i
//17-01-05 all the stuff above should go to Seq.Properties!
let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r))
//17-01-05 this applies to log_t's defined below.
let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b)
let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v
let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a)
////////////////////////////////////////////////////////////////////////////////
//Collecting monotone sequences
////////////////////////////////////////////////////////////////////////////////
(** yields the concatenation of all sequences returned by f applied to the sequence elements *)
val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s))
let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last)
val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a))
let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s)
#reset-options "--z3rlimit 20 --initial_fuel 1 --max_fuel 1 --initial_ifuel 1 --max_ifuel 1"
let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grows s1 s2)) (ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2))
= if length s1 = length s2 then assert (Seq.equal s1 s2)
else
let s2_prefix, s2_last = un_snoc s2 in
collect_grows_aux f s1 s2_prefix
in
Classical.arrow_to_impl #(grows s1 s2) #(grows (collect f s1) (collect f s2)) (fun _ -> collect_grows_aux f s1 s2)
let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r))
let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux
let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v
let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f)
////////////////////////////////////////////////////////////////////////////////
//Monotonic sequence numbers, bounded by the length of a log
////////////////////////////////////////////////////////////////////////////////
//17-01-05 the simpler variant, with an historic name; consider using uniform names below.
type log_t (i:rid) (a:Type) = m_rref i (seq a) grows
let increases (x:int) (y:int) = b2t (x <= y)
let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log)
//Note: we may want int seqn, instead of nat seqn
//because the handshake uses an initial value of -1
type seqn_val (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
(x:nat{x <= max /\ witnessed (at_most_log_len x log)}) //never more than the length of the log
type seqn (#l:rid) (#a:Type) (i:rid) (log:log_t l a) (max:nat) =
m_rref i //counter in region i
(seqn_val i log max) //never more than the length of the log
increases //increasing
let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Monotonic.Seq.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "FStar.Classical",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Monotonic",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | i: FStar.Monotonic.Seq.rid -> init: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.HyperStack.ST.ST (FStar.Monotonic.Seq.seqn i log max) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"FStar.HyperStack.ST.mref",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.at_most_log_len",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.recall_region",
"FStar.HyperStack.ST.recall",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.HyperStack.modifies_one",
"FStar.Monotonic.HyperStack.modifies_ref",
"FStar.Set.empty",
"FStar.Monotonic.HyperStack.fresh_ref",
"Prims.op_Equality",
"FStar.Map.contains",
"FStar.Monotonic.HyperHeap.rid",
"FStar.Monotonic.Heap.heap",
"FStar.Monotonic.HyperStack.get_hmap"
] | [] | false | true | false | false | false | let new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies_one i h0 h1 /\ modifies_ref i Set.empty h0 h1 /\ fresh_ref c h0 h1 /\
HS.sel h1 c = init /\ FStar.Map.contains (HS.get_hmap h1) i)) =
| reveal_opaque (`%grows) (grows #a);
recall log;
recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_keypair | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64) | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | Hacl.Frodo.KEM.crypto_kem_keypair_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_keypair",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_keypair pk sk =
| crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_publickeybytes | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64 | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_publickeybytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes"
] | [] | false | false | false | false | false | let crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
| normalize_term (crypto_publickeybytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_secretkeybytes | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 29,
"start_col": 0,
"start_line": 28
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64) | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_secretkeybytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_secretkeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes"
] | [] | false | false | false | false | false | let crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
| normalize_term (crypto_secretkeybytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_dec | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_dec ss ct sk =
crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 45,
"start_col": 0,
"start_line": 44
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64)
val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128
let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk
val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128
let crypto_kem_enc ct ss pk =
crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | Hacl.Frodo.KEM.crypto_kem_dec_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_dec",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_dec ss ct sk =
| crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_ciphertextbytes | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64) | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_ciphertextbytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.v",
"Spec.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes"
] | [] | false | false | false | false | false | let crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
| normalize_term (crypto_ciphertextbytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_enc | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_enc ct ss pk =
crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 41,
"start_col": 0,
"start_line": 40
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64
let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64)
let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64)
let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64)
val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128
let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Frodo64.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"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": "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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | Hacl.Frodo.KEM.crypto_kem_enc_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Frodo.KEM.crypto_kem_enc",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_enc ct ss pk =
| crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | false |
Lib.Exponentiation.fst | Lib.Exponentiation.b_acc | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
l: Prims.pos ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits / l}
-> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"FStar.Mul.op_Star"
] | [] | false | false | false | false | false | let b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat =
| b / pow2 (bBits - bBits % l - l * i) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_div_pow2i | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 47,
"start_col": 0,
"start_line": 45
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | bBits: Prims.nat -> b: Prims.nat{b < Prims.pow2 bBits} -> i: Prims.pos{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
b / Prims.pow2 (bBits - i) ==
(b / Prims.pow2 (bBits - i + 1)) * 2 + b / Prims.pow2 (bBits - i) % 2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Lib.Exponentiation.lemma_b_div_pow2ki",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int"
] | [] | true | false | true | false | false | let lemma_b_div_pow2i bBits b i =
| assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 151,
"start_col": 0,
"start_line": 147
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_lr k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"Lib.Exponentiation.exp_lr_lemma_loop",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_lr_f",
"Lib.Exponentiation.Definition.one"
] | [] | true | false | true | false | false | let exp_lr_lemma #t k a bBits b =
| let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_rl_lemma | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 96,
"start_col": 0,
"start_line": 92
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_rl k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Modulus",
"Lib.Exponentiation.exp_rl_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_rl_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one"
] | [] | false | false | true | false | false | let exp_rl_lemma #t k a bBits b =
| let acc, c = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma_step | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 120,
"start_col": 0,
"start_line": 108
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i < bBits} ->
acc1: t
-> FStar.Pervasives.Lemma
(requires acc1 == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))
(ensures
Lib.Exponentiation.exp_lr_f k a bBits b i acc1 ==
Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i - 1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow_add",
"FStar.Mul.op_Star",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Addition",
"Lib.Exponentiation.lemma_b_div_pow2i",
"Lib.Exponentiation.exp_lr_f"
] | [] | false | false | true | false | false | let exp_lr_lemma_step #t k a bBits b i acc1 =
| let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == (b / pow2 (bBits - i)) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a ((b / pow2 (bBits - i)) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0)
then ()
else
(assert (acc == mul (pow k a ((b / pow2 (bBits - i)) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a ((b / pow2 (bBits - i)) * 2) 1;
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma_loop | val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i))) | val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i))) | let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 144,
"start_col": 0,
"start_line": 130
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let acc =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_lr_f k a bBits b)
Lib.Exponentiation.Definition.one
in
acc == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow0",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_lr_f",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_lr_lemma_step",
"Prims.op_Subtraction",
"Lib.Exponentiation.exp_lr_lemma_loop",
"Lib.LoopCombinators.unfold_repeati",
"Lib.LoopCombinators.repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_lr_lemma_loop #t k a bBits b i =
| let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0
then
(Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
())
else
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
exp_lr_lemma_loop k a bBits b (i - 1);
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
() | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap2_lemma | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 251,
"start_col": 0,
"start_line": 250
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap2 k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_mont_ladder_swap2_lemma #t k a bBits b =
| exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_mod_pow2i | val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1)) | val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1)) | let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 20,
"start_col": 0,
"start_line": 11
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | bBits: Prims.nat -> b: Prims.nat{b < Prims.pow2 bBits} -> i: Prims.pos{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
b % Prims.pow2 i == (b / Prims.pow2 (i - 1) % 2) * Prims.pow2 (i - 1) + b % Prims.pow2 (i - 1)
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1"
] | [] | false | false | true | false | false | let lemma_b_mod_pow2i bBits b i =
| calc ( == ) {
b % pow2 i;
( == ) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
(b % pow2 i / pow2 (i - 1)) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
(b % pow2 i / pow2 (i - 1)) * pow2 (i - 1) + b % pow2 (i - 1);
( == ) { (Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i;
assert_norm (pow2 1 = 2)) }
(b / pow2 (i - 1) % 2) * pow2 (i - 1) + b % pow2 (i - 1);
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 225,
"start_col": 0,
"start_line": 222
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_mont_ladder_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_mont_ladder_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one"
] | [] | false | false | true | false | false | let exp_mont_ladder_lemma #t k a bBits b =
| let r0, r1 = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_rl_lemma_loop | val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i)) | val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i)) | let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 89,
"start_col": 0,
"start_line": 59
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits} ->
a: t
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_rl_f k bBits b)
(Lib.Exponentiation.Definition.one,
a)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ acc c = _ in
acc == Lib.Exponentiation.Definition.pow k a (b % Prims.pow2 i) /\
c == Lib.Exponentiation.Definition.pow k a (Prims.pow2 i))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow1",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Pervasives.assert_norm",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_rl_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.Definition.lemma_pow_add",
"Lib.Exponentiation.Definition.mul",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.Exponentiation.lemma_b_mod_pow2i",
"FStar.Math.Lemmas.pow2_double_sum",
"Prims.l_and",
"Lib.Exponentiation.exp_rl_lemma_loop",
"Lib.LoopCombinators.unfold_repeati",
"Lib.LoopCombinators.repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_rl_lemma_loop #t k bBits b i a =
| let acc, c = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0
then
(Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
())
else
let acc1, c1 = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == (b / pow2 (i - 1) % 2) * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1)
then
(assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma_step | val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1)))) | val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1)))) | let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 195,
"start_col": 0,
"start_line": 166
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1)))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
a: t ->
r0: t ->
r1: t ->
i: Prims.nat{i < bBits}
-> FStar.Pervasives.Lemma
(requires
r1 == Lib.Exponentiation.Definition.mul r0 a /\
r0 == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))
(ensures
(let _ = Lib.Exponentiation.exp_mont_ladder_f k bBits b i (r0, r1) in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ r0' r1' = _ in
r1' == Lib.Exponentiation.Definition.mul r0' a /\
r0' == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i - 1)))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_mul_comm",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.lemma_mul_assoc",
"Lib.Exponentiation.Definition.pow",
"Prims.bool",
"Lib.Exponentiation.Definition.lemma_pow_add",
"FStar.Mul.op_Star",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims.op_Addition",
"Lib.Exponentiation.lemma_b_div_pow2i",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_mont_ladder_f",
"FStar.Pervasives.Native.Mktuple2"
] | [] | false | false | true | false | false | let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
| let r0', r1' = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == (b / pow2 (bBits - i)) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a ((b / pow2 (bBits - i)) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0)
then
(assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
())
else
(assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a ((b / pow2 (bBits - i)) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_div_pow2ki | val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i) | val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i) | let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 40,
"start_col": 0,
"start_line": 27
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
k: Prims.pos ->
i: Prims.pos{i <= bBits / k}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.b_acc k bBits b (i - 1) * Prims.pow2 k +
Lib.Exponentiation.b_acc k bBits b i % Prims.pow2 k ==
Lib.Exponentiation.b_acc k bBits b i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.squash",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.distributivity_sub_right"
] | [] | false | false | true | false | false | let lemma_b_div_pow2ki bBits b k i =
| let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc ( == ) {
b / pow2 (bk - k * i);
( == ) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
(c / pow2 k) * pow2 k + c % pow2 k;
( == ) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
(b / (pow2 (bk - k * i) * pow2 k)) * pow2 k + c % pow2 k;
( == ) { Math.Lemmas.pow2_plus (bk - k * i) k }
(b / pow2 (bk - k * i + k)) * pow2 k + c % pow2 k;
( == ) { Math.Lemmas.distributivity_sub_right k i 1 }
(b / pow2 (bk - k * (i - 1))) * pow2 k + c % pow2 k;
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop | val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4) | val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4) | let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 247,
"start_col": 0,
"start_line": 238
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_swap2_f k bBits b)
(Lib.Exponentiation.Definition.one,
a)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ r0 r1 = _ in
let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_f k bBits b)
(Lib.Exponentiation.Definition.one,
a)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ r3 r4 = _ in
r0 == r3 /\ r1 == r4)
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_mont_ladder_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Exponentiation.Definition.one",
"Lib.Exponentiation.exp_mont_ladder_swap2_f",
"Prims.bool",
"Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop",
"Prims.op_Subtraction",
"Lib.LoopCombinators.unfold_repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
| if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
())
else
(Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma_loop | val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i))) | val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i))) | let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 219,
"start_col": 0,
"start_line": 205
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
a: t ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_f k bBits b)
(Lib.Exponentiation.Definition.one,
a)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ r0 r1 = _ in
r1 == Lib.Exponentiation.Definition.mul r0 a /\
r0 == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_mul_comm",
"Lib.Exponentiation.Definition.one",
"Lib.Exponentiation.Definition.lemma_one",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Math.Lemmas.small_div",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_mont_ladder_f",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"Lib.Exponentiation.exp_mont_ladder_lemma_step",
"Prims.op_Subtraction",
"Lib.Exponentiation.exp_mont_ladder_lemma_loop",
"Lib.LoopCombinators.unfold_repeati",
"Lib.LoopCombinators.repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
| let r0, r1 = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one;
())
else
let r0', r1' = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop | val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4)) | val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4)) | let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 274,
"start_col": 0,
"start_line": 265
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
sw0: Prims.nat{sw0 == b / Prims.pow2 bBits % 2} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_swap_f k bBits b)
(Lib.Exponentiation.Definition.one,
a,
sw0)
in
(let FStar.Pervasives.Native.Mktuple3 #_ #_ #_ r0 r1 sw = _ in
let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_f k bBits b)
(Lib.Exponentiation.cswap sw0 Lib.Exponentiation.Definition.one a)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ r3 r4 = _ in
let bit = b / Prims.pow2 (bBits - i) % 2 in
sw == bit /\ Lib.Exponentiation.cswap bit r0 r1 == (r3, r4))
<:
Type0)
<:
Type0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.unit",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_mont_ladder_f",
"Lib.Exponentiation.cswap",
"Lib.Exponentiation.Definition.one",
"FStar.Pervasives.Native.tuple3",
"Lib.Exponentiation.exp_mont_ladder_swap_f",
"FStar.Pervasives.Native.Mktuple3",
"Prims.bool",
"Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop",
"Prims.op_Subtraction",
"Lib.LoopCombinators.unfold_repeati"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
| if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
())
else
(Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_pow2_loop_lemma | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 294,
"start_col": 0,
"start_line": 284
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat -> i: Prims.nat{i <= b}
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeat i (Lib.Exponentiation.Definition.sqr k) a ==
Lib.Exponentiation.Definition.pow k a (Prims.pow2 i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Lib.LoopCombinators.eq_repeat0",
"Lib.Exponentiation.Definition.sqr",
"Prims.bool",
"FStar.Math.Lemmas.pow2_double_sum",
"Prims.op_Subtraction",
"Lib.Exponentiation.Definition.lemma_pow_add",
"Lib.Exponentiation.exp_pow2_loop_lemma",
"Lib.LoopCombinators.unfold_repeat"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_pow2_loop_lemma #t k a b i =
| if i = 0
then
(Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a)
else
(Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap_lemma | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 278,
"start_col": 0,
"start_line": 277
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_mont_ladder_swap_lemma #t k a bBits b =
| exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_pow2_lemma | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 296,
"start_col": 0,
"start_line": 296
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_pow2 k a b == Lib.Exponentiation.Definition.pow k a (Prims.pow2 b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Lib.Exponentiation.exp_pow2_loop_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_pow2_lemma #t k a b =
| exp_pow2_loop_lemma k a b b | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 404,
"start_col": 0,
"start_line": 393
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_fw k a bBits b l == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.b_acc",
"Lib.Exponentiation.exp_fw_lemma_loop",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_fw_f",
"Lib.Exponentiation.exp_fw_acc0_aux_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_fw_acc0"
] | [] | false | false | true | false | false | let exp_fw_lemma #t k a bBits b l =
| let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma_loop | val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i)) | val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i)) | let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 351,
"start_col": 0,
"start_line": 340
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.nat{i <= bBits / l}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b 0) in
let acc = Lib.LoopCombinators.repeati i (Lib.Exponentiation.exp_fw_f k a bBits b l) acc0 in
acc == Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b i))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_fw_f",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.exp_fw_lemma_step",
"Lib.Exponentiation.exp_fw_lemma_loop",
"Prims.op_Subtraction",
"Prims._assert",
"Prims.eq2",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.unfold_repeati",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_fw_lemma_loop #t k a bBits b l i =
| let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else
(Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
()) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_KeyExpansionRound | val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool | val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool | let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ()))))))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 48,
"start_col": 0,
"start_line": 37
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | round: Vale.X64.Memory.nat64 -> rcon: Vale.X64.Memory.nat8 -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsAes.va_codegen_success_AESNI_keygen_assist",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.InsVector.va_codegen_success_Pshufd",
"Vale.X64.InsVector.va_codegen_success_VPslldq4",
"Vale.X64.InsVector.va_codegen_success_Pxor",
"Vale.X64.InsVector.va_codegen_success_Store128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.op_Multiply",
"Prims.op_Addition",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_KeyExpansionRound round rcon =
| (va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255)
(va_pbool_and (va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_pbool_and (va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_pbool_and (va_codegen_success_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 1)
(va_op_xmm_xmm 3))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 1)
(va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet
1)
(va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1)
(16 `op_Multiply` (round + 1))
Secret)
(va_ttrue ()))))))))))) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 529,
"start_col": 0,
"start_line": 521
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_double_fw k a1 bBits b1 a2 b2 l ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k a1 b1)
(Lib.Exponentiation.Definition.pow k a2 b2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.exp_double_fw_lemma_loop",
"Prims.op_Division",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_double_fw_f",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc",
"Lib.Exponentiation.exp_double_fw_acc0_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_double_fw_acc0"
] | [] | false | false | true | false | false | let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
| let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_mul_assoc4 | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 543,
"start_col": 0,
"start_line": 536
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a1: t -> a2: t -> a3: t -> a4: t
-> FStar.Pervasives.Lemma
(ensures
Mkcomm_monoid?.mul k a1 (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a2 a3) a4) ==
Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a1 a2) a3) a4) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_assoc",
"Prims.squash"
] | [] | false | false | true | false | false | let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
| calc ( == ) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
( == ) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
( == ) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_acc0_lemma | val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0))) | val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0))) | let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 518,
"start_col": 0,
"start_line": 503
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| true -> Lib.Exponentiation.Definition.one
| _ -> Lib.Exponentiation.exp_double_fw_acc0 k a1 bBits b1 a2 b2 l)
<:
t
in
acc0 ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k
a1
(Lib.Exponentiation.b_acc l bBits b1 0))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 0)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"Lib.Exponentiation.Definition.lemma_one",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__one",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.small_div",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_fw_acc0_lemma",
"Prims.op_Subtraction"
] | [] | false | false | true | false | false | let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
| let bk = bBits - bBits % l in
if bBits % l = 0
then
let acc = one in
assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 ((bBits / l) * l) == 0);
assert (b2 / pow2 ((bBits / l) * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
()
else
(exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma_step | val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i)) | val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i)) | let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 328,
"start_col": 0,
"start_line": 309
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.pos{i <= bBits / l} ->
acc1: t
-> FStar.Pervasives.Lemma
(requires
acc1 == Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b (i - 1)))
(ensures
Lib.Exponentiation.exp_fw_f k a bBits b l (i - 1) acc1 ==
Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Lib.Exponentiation.Definition.lemma_pow_mul",
"Lib.Exponentiation.Definition.lemma_pow_add",
"Lib.Exponentiation.lemma_b_div_pow2ki",
"Prims._assert",
"FStar.Math.Lemmas.distributivity_sub_right",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Lib.Exponentiation.exp_pow2_lemma",
"Lib.Exponentiation.exp_fw_f"
] | [] | false | false | true | false | false | let exp_fw_lemma_step #t k a bBits b l i acc1 =
| let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc ( == ) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
( == ) { () }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
( == ) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
( == ) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
( == ) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_pow_distr_mul | val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x) | val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x) | let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 423,
"start_col": 0,
"start_line": 412
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
x: t ->
a: t ->
r1: Prims.nat ->
r2: Prims.nat ->
r3: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Mkcomm_monoid?.mul k
(Mkcomm_monoid?.mul k
x
(Lib.Exponentiation.Definition.pow k (Lib.Exponentiation.Definition.pow k a r1) r3))
(Lib.Exponentiation.Definition.pow k a r2) ==
Mkcomm_monoid?.mul k (Lib.Exponentiation.Definition.pow k a (r1 * r3 + r2)) x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Lib.Exponentiation.Definition.lemma_pow_mul",
"Prims.squash",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_assoc",
"Lib.Exponentiation.Definition.lemma_pow_add",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_comm"
] | [] | false | false | true | false | false | let lemma_pow_distr_mul #t k x a r1 r2 r3 =
| calc ( == ) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
( == ) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
( == ) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
( == ) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
( == ) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_acc0_lemma | val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem))) | val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem))) | let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0 then begin
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
Math.Lemmas.small_div b2 (pow2 bBits);
Math.Lemmas.small_div b3 (pow2 bBits);
Math.Lemmas.small_div b4 (pow2 bBits);
assert (b1_rem = 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_pow0 k a3;
lemma_pow0 k a4;
assert (
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)) ==
mul (mul one one) (mul one one));
lemma_one k.one;
() end
else begin
let acc_a1 = exp_fw_acc0 k a1 bBits b1 l in
let acc_a2 = exp_fw_acc0 k a2 bBits b2 l in
let acc_a3 = exp_fw_acc0 k a3 bBits b3 l in
let acc_a4 = exp_fw_acc0 k a4 bBits b4 l in
exp_fw_acc0_lemma k a1 bBits b1 l;
exp_fw_acc0_lemma k a2 bBits b2 l;
exp_fw_acc0_lemma k a3 bBits b3 l;
exp_fw_acc0_lemma k a4 bBits b4 l;
Math.Lemmas.euclidean_division_definition bBits l;
assert (acc_a1 == pow k a1 b1_rem);
assert (acc_a2 == pow k a2 b2_rem);
assert (acc_a3 == pow k a3 b3_rem);
assert (acc_a4 == pow k a4 b4_rem) end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 755,
"start_col": 0,
"start_line": 718
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4)
let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
}
val exp_four_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 (i - 1)))
(pow k a2 (b_acc l bBits b2 (i - 1))))
(pow k a3 (b_acc l bBits b3 (i - 1))))
(pow k a4 (b_acc l bBits b4 (i - 1))))
(ensures
exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1) acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 i))
(pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let exp_four_fw_lemma_step #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
let r31 = b_acc l bBits b3 (i - 1) in
let r32 = b_acc l bBits b3 i % pow2 l in
let r41 = b_acc l bBits b4 (i - 1) in
let r42 = b_acc l bBits b4 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
let res_a3 = pow k a3 (b_acc l bBits b3 i) in
let res_a4 = pow k a4 (b_acc l bBits b4 i) in
let acc_1 = pow k a1 r11 in
let acc_1_l = pow k acc_1 (pow2 l) in
let acc_12 = k.mul acc_1 (pow k a2 r21) in
let acc_12_l = pow k acc_12 (pow2 l) in
let acc_123 = k.mul acc_12 (pow k a3 r31) in
let acc_123_l = pow k acc_123 (pow2 l) in
calc (==) {
k.mul acc1 (pow k a4 r42);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a4 r42);
(==) { }
k.mul (pow k (k.mul acc_123 (pow k a4 r41)) (pow2 l)) (pow k a4 r42);
(==) { lemma_pow_mul_base k acc_123 (pow k a4 r41) (pow2 l) }
k.mul (k.mul acc_123_l (pow k (pow k a4 r41) (pow2 l))) (pow k a4 r42);
(==) { lemma_pow_distr_mul k acc_123_l a4 r41 r42 (pow2 l) }
k.mul (pow k a4 (r41 * pow2 l + r42)) acc_123_l;
(==) { lemma_b_div_pow2ki bBits b4 l i }
k.mul res_a4 acc_123_l;
};
calc (==) {
k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32);
(==) { }
k.mul (k.mul res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l))) (pow k a3 r32);
(==) {k.lemma_mul_assoc res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32)}
k.mul res_a4 (k.mul (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32));
(==) { lemma_pow_mul_base k acc_12 (pow k a3 r31) (pow2 l) }
k.mul res_a4 (k.mul (k.mul acc_12_l (pow k (pow k a3 r31) (pow2 l))) (pow k a3 r32));
(==) { lemma_pow_distr_mul k acc_12_l a3 r31 r32 (pow2 l) }
k.mul res_a4 (k.mul (pow k a3 (r31 * pow2 l + r32)) acc_12_l);
(==) { lemma_b_div_pow2ki bBits b3 l i }
k.mul res_a4 (k.mul res_a3 acc_12_l);
(==) { k.lemma_mul_assoc res_a4 res_a3 acc_12_l; k.lemma_mul_comm res_a4 res_a3 }
k.mul (k.mul res_a3 res_a4) acc_12_l;
};
let res_a234 = k.mul (k.mul res_a2 res_a3) res_a4 in
let res_a34 = k.mul res_a3 res_a4 in
calc (==) {
k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22);
(==) { }
k.mul (k.mul res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l))) (pow k a2 r22);
(==) { lemma_mul_assoc res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22) }
k.mul res_a34 (k.mul (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22));
(==) { lemma_pow_mul_base k acc_1 (pow k a2 r21) (pow2 l) }
k.mul res_a34 (k.mul (k.mul acc_1_l (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22));
(==) { lemma_pow_distr_mul k acc_1_l a2 r21 r22 (pow2 l) }
k.mul res_a34 (k.mul (pow k a2 (r21 * pow2 l + r22)) acc_1_l);
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a34 (k.mul res_a2 acc_1_l);
(==) { k.lemma_mul_assoc res_a34 res_a2 acc_1_l; k.lemma_mul_comm res_a34 res_a2 }
k.mul (k.mul res_a2 res_a34) acc_1_l;
(==) { k.lemma_mul_assoc res_a2 res_a3 res_a4 }
k.mul res_a234 acc_1_l;
};
calc (==) {
k.mul (k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a234 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a234 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a234;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 (k.mul (k.mul res_a2 res_a3) res_a4);
(==) { lemma_mul_assoc4 k res_a1 res_a2 res_a3 res_a4 }
k.mul (k.mul (k.mul res_a1 res_a2) res_a3) res_a4;
}
val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0
else begin
Loops.unfold_repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1);
exp_four_fw_lemma_step k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc1;
() end
val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| true -> Lib.Exponentiation.Definition.one
| _ -> Lib.Exponentiation.exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l)
<:
t
in
let b1_rem = Lib.Exponentiation.b_acc l bBits b1 0 in
let b2_rem = Lib.Exponentiation.b_acc l bBits b2 0 in
let b3_rem = Lib.Exponentiation.b_acc l bBits b3 0 in
let b4_rem = Lib.Exponentiation.b_acc l bBits b4 0 in
acc0 ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow
k
a1
b1_rem)
(Lib.Exponentiation.Definition.pow k a2 b2_rem))
(Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k a3 b3_rem)
(Lib.Exponentiation.Definition.pow k a4 b4_rem)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_one",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__one",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.Definition.one",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Math.Lemmas.small_div",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Prims.bool",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.exp_fw_acc0_lemma",
"Lib.Exponentiation.exp_fw_acc0",
"Lib.Exponentiation.b_acc"
] | [] | false | false | true | false | false | let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
| let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0
then
(assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
Math.Lemmas.small_div b2 (pow2 bBits);
Math.Lemmas.small_div b3 (pow2 bBits);
Math.Lemmas.small_div b4 (pow2 bBits);
assert (b1_rem = 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_pow0 k a3;
lemma_pow0 k a4;
assert (mul (mul (pow k a1 b1_rem) (pow k a2 b2_rem)) (mul (pow k a3 b3_rem) (pow k a4 b4_rem)) ==
mul (mul one one) (mul one one));
lemma_one k.one;
())
else
let acc_a1 = exp_fw_acc0 k a1 bBits b1 l in
let acc_a2 = exp_fw_acc0 k a2 bBits b2 l in
let acc_a3 = exp_fw_acc0 k a3 bBits b3 l in
let acc_a4 = exp_fw_acc0 k a4 bBits b4 l in
exp_fw_acc0_lemma k a1 bBits b1 l;
exp_fw_acc0_lemma k a2 bBits b2 l;
exp_fw_acc0_lemma k a3 bBits b3 l;
exp_fw_acc0_lemma k a4 bBits b4 l;
Math.Lemmas.euclidean_division_definition bBits l;
assert (acc_a1 == pow k a1 b1_rem);
assert (acc_a2 == pow k a2 b2_rem);
assert (acc_a3 == pow k a3 b3_rem);
assert (acc_a4 == pow k a4 b4_rem) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_acc0_aux_lemma | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 390,
"start_col": 0,
"start_line": 380
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| true -> Lib.Exponentiation.Definition.one
| _ -> Lib.Exponentiation.exp_fw_acc0 k a bBits b l)
<:
t
in
acc0 == Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b 0))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Mul.op_Star",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Math.Lemmas.small_div",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_fw_acc0_lemma"
] | [] | false | false | true | false | false | let exp_fw_acc0_aux_lemma #t k a bBits b l =
| if bBits % l = 0
then
let acc = one in
assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 ((bBits / l) * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 ((bBits / l) * l)));
()
else exp_fw_acc0_lemma #t k a bBits b l | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma_loop | val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 494,
"start_col": 0,
"start_line": 483
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.nat{i <= bBits / l}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k
a1
(Lib.Exponentiation.b_acc l bBits b1 0))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 0))
in
let acc =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_double_fw_f k a1 bBits b1 a2 b2 l)
acc0
in
acc ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k
a1
(Lib.Exponentiation.b_acc l bBits b1 i))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 i)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_double_fw_f",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.exp_double_fw_lemma_step",
"Lib.Exponentiation.exp_double_fw_lemma_loop",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.unfold_repeati",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
| let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else
(Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
()) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansionRound | val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code | val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code | let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ())))))))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 33,
"start_col": 0,
"start_line": 24
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | round: Vale.X64.Memory.nat64 -> rcon: Vale.X64.Memory.nat8 -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsAes.va_code_AESNI_keygen_assist",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.InsVector.va_code_Pshufd",
"Vale.X64.InsVector.va_code_VPslldq4",
"Vale.X64.InsVector.va_code_Pxor",
"Vale.X64.InsVector.va_code_Store128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.op_Multiply",
"Prims.op_Addition",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_KeyExpansionRound round rcon =
| (va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255)
(va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2))
(va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet
1)
(va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1)
(16 `op_Multiply` (round + 1))
Secret)
(va_CNil ())))))))))))) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_lemma | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow k a2 b2)) (pow k a3 b3)) (pow k a4 b4)) | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow k a2 b2)) (pow k a3 b3)) (pow k a4 b4)) | let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l;
assert (acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)));
k.lemma_mul_assoc (k.mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(pow k a3 b3_rem) (pow k a4 b4_rem);
Math.Lemmas.euclidean_division_definition bBits l;
let res =
Loops.repeati (bBits / l)
(exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (bBits / l);
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 780,
"start_col": 0,
"start_line": 758
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4)
let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
}
val exp_four_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 (i - 1)))
(pow k a2 (b_acc l bBits b2 (i - 1))))
(pow k a3 (b_acc l bBits b3 (i - 1))))
(pow k a4 (b_acc l bBits b4 (i - 1))))
(ensures
exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1) acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 i))
(pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let exp_four_fw_lemma_step #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
let r31 = b_acc l bBits b3 (i - 1) in
let r32 = b_acc l bBits b3 i % pow2 l in
let r41 = b_acc l bBits b4 (i - 1) in
let r42 = b_acc l bBits b4 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
let res_a3 = pow k a3 (b_acc l bBits b3 i) in
let res_a4 = pow k a4 (b_acc l bBits b4 i) in
let acc_1 = pow k a1 r11 in
let acc_1_l = pow k acc_1 (pow2 l) in
let acc_12 = k.mul acc_1 (pow k a2 r21) in
let acc_12_l = pow k acc_12 (pow2 l) in
let acc_123 = k.mul acc_12 (pow k a3 r31) in
let acc_123_l = pow k acc_123 (pow2 l) in
calc (==) {
k.mul acc1 (pow k a4 r42);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a4 r42);
(==) { }
k.mul (pow k (k.mul acc_123 (pow k a4 r41)) (pow2 l)) (pow k a4 r42);
(==) { lemma_pow_mul_base k acc_123 (pow k a4 r41) (pow2 l) }
k.mul (k.mul acc_123_l (pow k (pow k a4 r41) (pow2 l))) (pow k a4 r42);
(==) { lemma_pow_distr_mul k acc_123_l a4 r41 r42 (pow2 l) }
k.mul (pow k a4 (r41 * pow2 l + r42)) acc_123_l;
(==) { lemma_b_div_pow2ki bBits b4 l i }
k.mul res_a4 acc_123_l;
};
calc (==) {
k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32);
(==) { }
k.mul (k.mul res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l))) (pow k a3 r32);
(==) {k.lemma_mul_assoc res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32)}
k.mul res_a4 (k.mul (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32));
(==) { lemma_pow_mul_base k acc_12 (pow k a3 r31) (pow2 l) }
k.mul res_a4 (k.mul (k.mul acc_12_l (pow k (pow k a3 r31) (pow2 l))) (pow k a3 r32));
(==) { lemma_pow_distr_mul k acc_12_l a3 r31 r32 (pow2 l) }
k.mul res_a4 (k.mul (pow k a3 (r31 * pow2 l + r32)) acc_12_l);
(==) { lemma_b_div_pow2ki bBits b3 l i }
k.mul res_a4 (k.mul res_a3 acc_12_l);
(==) { k.lemma_mul_assoc res_a4 res_a3 acc_12_l; k.lemma_mul_comm res_a4 res_a3 }
k.mul (k.mul res_a3 res_a4) acc_12_l;
};
let res_a234 = k.mul (k.mul res_a2 res_a3) res_a4 in
let res_a34 = k.mul res_a3 res_a4 in
calc (==) {
k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22);
(==) { }
k.mul (k.mul res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l))) (pow k a2 r22);
(==) { lemma_mul_assoc res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22) }
k.mul res_a34 (k.mul (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22));
(==) { lemma_pow_mul_base k acc_1 (pow k a2 r21) (pow2 l) }
k.mul res_a34 (k.mul (k.mul acc_1_l (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22));
(==) { lemma_pow_distr_mul k acc_1_l a2 r21 r22 (pow2 l) }
k.mul res_a34 (k.mul (pow k a2 (r21 * pow2 l + r22)) acc_1_l);
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a34 (k.mul res_a2 acc_1_l);
(==) { k.lemma_mul_assoc res_a34 res_a2 acc_1_l; k.lemma_mul_comm res_a34 res_a2 }
k.mul (k.mul res_a2 res_a34) acc_1_l;
(==) { k.lemma_mul_assoc res_a2 res_a3 res_a4 }
k.mul res_a234 acc_1_l;
};
calc (==) {
k.mul (k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a234 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a234 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a234;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 (k.mul (k.mul res_a2 res_a3) res_a4);
(==) { lemma_mul_assoc4 k res_a1 res_a2 res_a3 res_a4 }
k.mul (k.mul (k.mul res_a1 res_a2) res_a3) res_a4;
}
val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0
else begin
Loops.unfold_repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1);
exp_four_fw_lemma_step k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc1;
() end
val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
acc0 ==
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)))
let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0 then begin
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
Math.Lemmas.small_div b2 (pow2 bBits);
Math.Lemmas.small_div b3 (pow2 bBits);
Math.Lemmas.small_div b4 (pow2 bBits);
assert (b1_rem = 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_pow0 k a3;
lemma_pow0 k a4;
assert (
mul
(mul (pow k a1 b1_rem) (pow k a2 b2_rem))
(mul (pow k a3 b3_rem) (pow k a4 b4_rem)) ==
mul (mul one one) (mul one one));
lemma_one k.one;
() end
else begin
let acc_a1 = exp_fw_acc0 k a1 bBits b1 l in
let acc_a2 = exp_fw_acc0 k a2 bBits b2 l in
let acc_a3 = exp_fw_acc0 k a3 bBits b3 l in
let acc_a4 = exp_fw_acc0 k a4 bBits b4 l in
exp_fw_acc0_lemma k a1 bBits b1 l;
exp_fw_acc0_lemma k a2 bBits b2 l;
exp_fw_acc0_lemma k a3 bBits b3 l;
exp_fw_acc0_lemma k a4 bBits b4 l;
Math.Lemmas.euclidean_division_definition bBits l;
assert (acc_a1 == pow k a1 b1_rem);
assert (acc_a2 == pow k a2 b2_rem);
assert (acc_a3 == pow k a3 b3_rem);
assert (acc_a4 == pow k a4 b4_rem) end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul
(Lib.Exponentiation.Definition.pow k a1 b1)
(Lib.Exponentiation.Definition.pow k a2 b2))
(Lib.Exponentiation.Definition.pow k a3 b3))
(Lib.Exponentiation.Definition.pow k a4 b4)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_four_fw_lemma_loop",
"Prims.op_Division",
"Lib.LoopCombinators.repeati",
"Lib.Exponentiation.exp_four_fw_f",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__lemma_mul_assoc",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.exp_four_fw_acc0_lemma",
"Prims.op_Modulus",
"Lib.Exponentiation.Definition.one",
"Prims.bool",
"Lib.Exponentiation.exp_four_fw_acc0",
"Lib.Exponentiation.b_acc"
] | [] | false | false | true | false | false | let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
| let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 = if bBits % l = 0 then one else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l;
assert (acc0 ==
mul (mul (pow k a1 b1_rem) (pow k a2 b2_rem)) (mul (pow k a3 b3_rem) (pow k a4 b4_rem)));
k.lemma_mul_assoc (k.mul (pow k a1 b1_rem) (pow k a2 b2_rem)) (pow k a3 b3_rem) (pow k a4 b4_rem);
Math.Lemmas.euclidean_division_definition bBits l;
let res = Loops.repeati (bBits / l) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (bBits / l);
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_acc0_lemma | val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0)) | val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0)) | let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 370,
"start_col": 0,
"start_line": 360
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos{bBits % l <> 0}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_fw_acc0 k a bBits b l ==
Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b 0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_disEquality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.small_mod",
"FStar.Math.Lemmas.pow2_lt_compat",
"FStar.Math.Lemmas.lemma_div_lt_nat",
"Lib.Exponentiation.get_ith_lbits"
] | [] | true | false | true | false | false | let exp_fw_acc0_lemma #t k a bBits b l =
| let bits_c = get_ith_lbits bBits b ((bBits / l) * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 ((bBits / l) * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits ((bBits / l) * l);
assert (b / pow2 ((bBits / l) * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 ((bBits / l) * l)) (pow2 l);
assert (bits_c == b / pow2 ((bBits / l) * l));
assert (acc == pow k a (b / pow2 ((bBits / l) * l)));
() | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansion128Stdcall | val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code | val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code | let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
())))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 308,
"start_col": 0,
"start_line": 298
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | win: Prims.bool -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRcx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.InsBasic.va_code_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Decls.va_code",
"Vale.X64.InsVector.va_code_Store128_buffer",
"Vale.AES.X64.AES128.va_code_KeyExpansionRoundUnrolledRecursive",
"Vale.X64.InsVector.va_code_Pxor"
] | [] | false | false | false | true | false | let va_code_KeyExpansion128Stdcall win =
| (va_Block (va_CCons (if win
then
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx)
0
Secret)
(va_CNil ()))
else
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRdi)
0
Secret)
(va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi))
(va_CNil ()))))
(va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1)
0
Secret)
(va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10)
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil ()))))
)))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_KeyExpansion128Stdcall | val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool | val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool | let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ()))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 322,
"start_col": 0,
"start_line": 311
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
())))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | win: Prims.bool -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRcx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Machine_s.rRdi",
"Vale.X64.InsBasic.va_codegen_success_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Decls.va_pbool",
"Vale.X64.InsVector.va_codegen_success_Store128_buffer",
"Vale.AES.X64.AES128.va_codegen_success_KeyExpansionRoundUnrolledRecursive",
"Vale.X64.InsVector.va_codegen_success_Pxor"
] | [] | false | false | false | true | false | let va_codegen_success_KeyExpansion128Stdcall win =
| (va_pbool_and (if win
then
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx)
0
Secret)
(va_ttrue ())
else
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRdi)
0
Secret)
(va_pbool_and (va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx)
(va_op_opr64_reg64 rRsi))
(va_ttrue ())))
(va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1)
0
Secret)
(va_pbool_and (va_codegen_success_KeyExpansionRoundUnrolledRecursive 10)
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3))
(va_ttrue ()))))))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptRound | val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool | val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool | let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ()))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 434,
"start_col": 0,
"start_line": 431
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ()))))
val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Prims.op_Multiply",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsAes.va_codegen_success_AESNI_enc",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptRound n =
| (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` n)
Secret)
(va_pbool_and (va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ()))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptRound | val va_code_AES128EncryptRound : n:nat -> Tot va_code | val va_code_AES128EncryptRound : n:nat -> Tot va_code | let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ())))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 427,
"start_col": 0,
"start_line": 424
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.nat -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Prims.op_Multiply",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsAes.va_code_AESNI_enc",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_AES128EncryptRound n =
| (va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` n)
Secret)
(va_CCons (va_code_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ())))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptBlock | val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code | val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code | let va_code_AES128EncryptBlock () =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) 0 Secret) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons (va_code_AES128EncryptRound 1)
(va_CCons (va_code_AES128EncryptRound 2) (va_CCons (va_code_AES128EncryptRound 3) (va_CCons
(va_code_AES128EncryptRound 4) (va_CCons (va_code_AES128EncryptRound 5) (va_CCons
(va_code_AES128EncryptRound 6) (va_CCons (va_code_AES128EncryptRound 7) (va_CCons
(va_code_AES128EncryptRound 8) (va_CCons (va_code_AES128EncryptRound 9) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret) (va_CCons (va_code_AESNI_enc_last (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_CNil
()))))))))))))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 533,
"start_col": 0,
"start_line": 522
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ()))))
val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptRound (va_mods:va_mods_t) (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(va_arg5:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 188 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg5) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 189 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` n) Secret keys_buffer n) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 190 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QEmpty (()))))))
val va_lemma_AES128EncryptRound : va_b0:va_code -> va_s0:va_state -> n:nat -> init:quad32 ->
round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptRound n) va_s0 /\ va_get_ok va_s0 /\
(aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <= FStar.Seq.Base.length #quad32
round_keys) /\ va_get_xmm 0 va_s0 == Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\
va_get_reg64 rR8 va_s0 == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.buffer128_read keys_buffer n (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys n))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptRound va_b0 va_s0 n init round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptRound va_mods n init round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptRound n) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 168 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 186 column 53 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <=
FStar.Seq.Base.length #quad32 round_keys) /\ va_get_xmm 0 va_s0 ==
Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\ va_get_reg64 rR8 va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0)
/\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rR8 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer128_read keys_buffer n
(va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #quad32 round_keys n /\ (forall
(va_x_xmm0:quad32) (va_x_xmm2:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n ==> va_k va_sM (())))
val va_wpProof_AES128EncryptRound : n:nat -> init:quad32 -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptRound n init round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptRound n) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptRound n init round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptRound (va_code_AES128EncryptRound n) va_s0 n init
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(va_QProc (va_code_AES128EncryptRound n) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptRound n init round_keys keys_buffer) (va_wpProof_AES128EncryptRound n init
round_keys keys_buffer))
//--
//-- AES128EncryptBlock | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.Decls.va_CNil",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsVector.va_code_Pxor",
"Vale.AES.X64.AES128.va_code_AES128EncryptRound",
"Prims.op_Multiply",
"Vale.X64.InsAes.va_code_AESNI_enc_last",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_AES128EncryptBlock () =
| (va_Block (va_CCons (va_Block (va_CNil ()))
(va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
0
Secret)
(va_CCons (va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2))
(va_CCons (va_code_AES128EncryptRound 1)
(va_CCons (va_code_AES128EncryptRound 2)
(va_CCons (va_code_AES128EncryptRound 3)
(va_CCons (va_code_AES128EncryptRound 4)
(va_CCons (va_code_AES128EncryptRound 5)
(va_CCons (va_code_AES128EncryptRound 6)
(va_CCons (va_code_AES128EncryptRound 7)
(va_CCons (va_code_AES128EncryptRound 8)
(va_CCons (va_code_AES128EncryptRound 9)
(va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet
0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` 10)
Secret)
(va_CCons (va_code_AESNI_enc_last (va_op_xmm_xmm
0)
(va_op_xmm_xmm 2))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 2
)
(va_op_xmm_xmm 2))
(va_CNil ()))))))))))))))))) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_lemma_loop | val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i))) | val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i))) | let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0
else begin
Loops.unfold_repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1);
exp_four_fw_lemma_step k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc1;
() end | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 697,
"start_col": 0,
"start_line": 681
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
}
val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
acc == mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin
Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (i - 1);
exp_double_fw_lemma_step k a1 bBits b1 a2 b2 l i acc1;
() end
val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (pow k a1 (b1 / pow2 bk)) (pow k a2 (b2 / pow2 bk)));
() end
else begin
exp_fw_acc0_lemma #t k a1 bBits b1 l;
exp_fw_acc0_lemma #t k a2 bBits b2 l end
let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw_lemma_loop k a1 bBits b1 a2 b2 l (bBits / l);
Math.Lemmas.euclidean_division_definition bBits l;
assert_norm (pow2 0 = 1)
//-------------------------
val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4)
let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
}
val exp_four_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 (i - 1)))
(pow k a2 (b_acc l bBits b2 (i - 1))))
(pow k a3 (b_acc l bBits b3 (i - 1))))
(pow k a4 (b_acc l bBits b4 (i - 1))))
(ensures
exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1) acc ==
k.mul
(k.mul
(k.mul
(pow k a1 (b_acc l bBits b1 i))
(pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i)))
let exp_four_fw_lemma_step #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
let r31 = b_acc l bBits b3 (i - 1) in
let r32 = b_acc l bBits b3 i % pow2 l in
let r41 = b_acc l bBits b4 (i - 1) in
let r42 = b_acc l bBits b4 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
let res_a3 = pow k a3 (b_acc l bBits b3 i) in
let res_a4 = pow k a4 (b_acc l bBits b4 i) in
let acc_1 = pow k a1 r11 in
let acc_1_l = pow k acc_1 (pow2 l) in
let acc_12 = k.mul acc_1 (pow k a2 r21) in
let acc_12_l = pow k acc_12 (pow2 l) in
let acc_123 = k.mul acc_12 (pow k a3 r31) in
let acc_123_l = pow k acc_123 (pow2 l) in
calc (==) {
k.mul acc1 (pow k a4 r42);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a4 r42);
(==) { }
k.mul (pow k (k.mul acc_123 (pow k a4 r41)) (pow2 l)) (pow k a4 r42);
(==) { lemma_pow_mul_base k acc_123 (pow k a4 r41) (pow2 l) }
k.mul (k.mul acc_123_l (pow k (pow k a4 r41) (pow2 l))) (pow k a4 r42);
(==) { lemma_pow_distr_mul k acc_123_l a4 r41 r42 (pow2 l) }
k.mul (pow k a4 (r41 * pow2 l + r42)) acc_123_l;
(==) { lemma_b_div_pow2ki bBits b4 l i }
k.mul res_a4 acc_123_l;
};
calc (==) {
k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32);
(==) { }
k.mul (k.mul res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l))) (pow k a3 r32);
(==) {k.lemma_mul_assoc res_a4 (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32)}
k.mul res_a4 (k.mul (pow k (k.mul acc_12 (pow k a3 r31)) (pow2 l)) (pow k a3 r32));
(==) { lemma_pow_mul_base k acc_12 (pow k a3 r31) (pow2 l) }
k.mul res_a4 (k.mul (k.mul acc_12_l (pow k (pow k a3 r31) (pow2 l))) (pow k a3 r32));
(==) { lemma_pow_distr_mul k acc_12_l a3 r31 r32 (pow2 l) }
k.mul res_a4 (k.mul (pow k a3 (r31 * pow2 l + r32)) acc_12_l);
(==) { lemma_b_div_pow2ki bBits b3 l i }
k.mul res_a4 (k.mul res_a3 acc_12_l);
(==) { k.lemma_mul_assoc res_a4 res_a3 acc_12_l; k.lemma_mul_comm res_a4 res_a3 }
k.mul (k.mul res_a3 res_a4) acc_12_l;
};
let res_a234 = k.mul (k.mul res_a2 res_a3) res_a4 in
let res_a34 = k.mul res_a3 res_a4 in
calc (==) {
k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22);
(==) { }
k.mul (k.mul res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l))) (pow k a2 r22);
(==) { lemma_mul_assoc res_a34 (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22) }
k.mul res_a34 (k.mul (pow k (k.mul acc_1 (pow k a2 r21)) (pow2 l)) (pow k a2 r22));
(==) { lemma_pow_mul_base k acc_1 (pow k a2 r21) (pow2 l) }
k.mul res_a34 (k.mul (k.mul acc_1_l (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22));
(==) { lemma_pow_distr_mul k acc_1_l a2 r21 r22 (pow2 l) }
k.mul res_a34 (k.mul (pow k a2 (r21 * pow2 l + r22)) acc_1_l);
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a34 (k.mul res_a2 acc_1_l);
(==) { k.lemma_mul_assoc res_a34 res_a2 acc_1_l; k.lemma_mul_comm res_a34 res_a2 }
k.mul (k.mul res_a2 res_a34) acc_1_l;
(==) { k.lemma_mul_assoc res_a2 res_a3 res_a4 }
k.mul res_a234 acc_1_l;
};
calc (==) {
k.mul (k.mul (k.mul (k.mul acc1 (pow k a4 r42)) (pow k a3 r32)) (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a234 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a234 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a234;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 (k.mul (k.mul res_a2 res_a3) res_a4);
(==) { lemma_mul_assoc4 k res_a1 res_a2 res_a3 res_a4 }
k.mul (k.mul (k.mul res_a1 res_a2) res_a3) res_a4;
}
val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
acc ==
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i)))
(pow k a3 (b_acc l bBits b3 i)))
(pow k a4 (b_acc l bBits b4 i))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.nat{i <= bBits / l}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul
(Lib.Exponentiation.Definition.pow k a1 (Lib.Exponentiation.b_acc l bBits b1 0))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 0))
)
(Lib.Exponentiation.Definition.pow k a3 (Lib.Exponentiation.b_acc l bBits b3 0)))
(Lib.Exponentiation.Definition.pow k a4 (Lib.Exponentiation.b_acc l bBits b4 0))
in
let acc =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l)
acc0
in
acc ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.mul
(Lib.Exponentiation.Definition.pow k a1 (Lib.Exponentiation.b_acc l bBits b1 i))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 i)))
(Lib.Exponentiation.Definition.pow k a3 (Lib.Exponentiation.b_acc l bBits b3 i)))
(Lib.Exponentiation.Definition.pow k a4 (Lib.Exponentiation.b_acc l bBits b4 i)))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_four_fw_f",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.exp_four_fw_lemma_step",
"Lib.Exponentiation.exp_four_fw_lemma_loop",
"Prims.op_Subtraction",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.unfold_repeati",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",
"Lib.Exponentiation.b_acc"
] | [
"recursion"
] | false | false | true | false | false | let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
| let acc0 =
mul (mul (mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0))
in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0
else
(Loops.unfold_repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
exp_four_fw_lemma_loop k a1 bBits b1 a2 b2 a3 b3 a4 b4 l (i - 1);
exp_four_fw_lemma_step k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i acc1;
()) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptBlock | val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool | val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool | let va_codegen_success_AES128EncryptBlock () =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) 0 Secret) (va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_AES128EncryptRound 1) (va_pbool_and
(va_codegen_success_AES128EncryptRound 2) (va_pbool_and (va_codegen_success_AES128EncryptRound
3) (va_pbool_and (va_codegen_success_AES128EncryptRound 4) (va_pbool_and
(va_codegen_success_AES128EncryptRound 5) (va_pbool_and (va_codegen_success_AES128EncryptRound
6) (va_pbool_and (va_codegen_success_AES128EncryptRound 7) (va_pbool_and
(va_codegen_success_AES128EncryptRound 8) (va_pbool_and (va_codegen_success_AES128EncryptRound
9) (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` 10) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc_last (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_ttrue ()))))))))))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 548,
"start_col": 0,
"start_line": 536
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ()))))
val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptRound (va_mods:va_mods_t) (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(va_arg5:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 188 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg5) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 189 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` n) Secret keys_buffer n) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 190 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QEmpty (()))))))
val va_lemma_AES128EncryptRound : va_b0:va_code -> va_s0:va_state -> n:nat -> init:quad32 ->
round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptRound n) va_s0 /\ va_get_ok va_s0 /\
(aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <= FStar.Seq.Base.length #quad32
round_keys) /\ va_get_xmm 0 va_s0 == Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\
va_get_reg64 rR8 va_s0 == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.buffer128_read keys_buffer n (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys n))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptRound va_b0 va_s0 n init round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptRound va_mods n init round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptRound n) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 168 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 186 column 53 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <=
FStar.Seq.Base.length #quad32 round_keys) /\ va_get_xmm 0 va_s0 ==
Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\ va_get_reg64 rR8 va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0)
/\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rR8 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer128_read keys_buffer n
(va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #quad32 round_keys n /\ (forall
(va_x_xmm0:quad32) (va_x_xmm2:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n ==> va_k va_sM (())))
val va_wpProof_AES128EncryptRound : n:nat -> init:quad32 -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptRound n init round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptRound n) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptRound n init round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptRound (va_code_AES128EncryptRound n) va_s0 n init
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(va_QProc (va_code_AES128EncryptRound n) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptRound n init round_keys keys_buffer) (va_wpProof_AES128EncryptRound n init
round_keys keys_buffer))
//--
//-- AES128EncryptBlock
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptBlock () =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) 0 Secret) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons (va_code_AES128EncryptRound 1)
(va_CCons (va_code_AES128EncryptRound 2) (va_CCons (va_code_AES128EncryptRound 3) (va_CCons
(va_code_AES128EncryptRound 4) (va_CCons (va_code_AES128EncryptRound 5) (va_CCons
(va_code_AES128EncryptRound 6) (va_CCons (va_code_AES128EncryptRound 7) (va_CCons
(va_code_AES128EncryptRound 8) (va_CCons (va_code_AES128EncryptRound 9) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret) (va_CCons (va_code_AESNI_enc_last (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_CNil
()))))))))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsVector.va_codegen_success_Pxor",
"Vale.AES.X64.AES128.va_codegen_success_AES128EncryptRound",
"Prims.op_Multiply",
"Vale.X64.InsAes.va_codegen_success_AESNI_enc_last",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptBlock () =
| (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
0
Secret)
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_AES128EncryptRound 1)
(va_pbool_and (va_codegen_success_AES128EncryptRound 2)
(va_pbool_and (va_codegen_success_AES128EncryptRound 3)
(va_pbool_and (va_codegen_success_AES128EncryptRound 4)
(va_pbool_and (va_codegen_success_AES128EncryptRound 5)
(va_pbool_and (va_codegen_success_AES128EncryptRound 6)
(va_pbool_and (va_codegen_success_AES128EncryptRound 7)
(va_pbool_and (va_codegen_success_AES128EncryptRound 8)
(va_pbool_and (va_codegen_success_AES128EncryptRound 9)
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` 10)
Secret)
(va_pbool_and (va_codegen_success_AESNI_enc_last (va_op_xmm_xmm
0)
(va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm
2)
(va_op_xmm_xmm 2))
(va_ttrue ()))))))))))))))) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma_step | val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc (==) {
k.mul acc1 (pow k a2 r22);
(==) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
(==) { }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
(==) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
(==) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
(==) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc (==) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
(==) { }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
(==) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
(==) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 470,
"start_col": 0,
"start_line": 437
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 b (i - 1) i; assert_norm (pow2 1 = 2) }
b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1);
}
let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i)
val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i)
let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
b / (pow2 (bk - k * i) * pow2 k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.pow2_plus (bk - k * i) k }
b / pow2 (bk - k * i + k) * pow2 k + c % pow2 k;
(==) { Math.Lemmas.distributivity_sub_right k i 1 }
b / pow2 (bk - k * (i - 1)) * pow2 k + c % pow2 k;
}
val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2)
let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i
//------------------------------
val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i))
let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f k bBits b) (one, a) (i - 1);
exp_rl_lemma_loop #t k bBits b (i - 1) a;
assert (acc1 == pow k a (b % pow2 (i - 1)) /\ c1 == pow k a (pow2 (i - 1)));
//assert (c == k.mul c1 c1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
assert (c == pow k a (pow2 i));
lemma_b_mod_pow2i bBits b i;
assert (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1));
if (b / pow2 (i - 1) % 2 = 1) then begin
//assert (acc == acc1 * a1);
assert (acc == mul (pow k a (b % pow2 (i - 1))) (pow k a (pow2 (i - 1))));
lemma_pow_add k a (b % pow2 (i - 1)) (pow2 (i - 1));
assert (acc == pow k a (b % pow2 i));
() end
else () end
let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits)
//------------------------------
val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1)))
let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then ()
else begin
assert (acc == mul (pow k a (b / pow2 (bBits - i) * 2)) a);
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
() end
val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i)))
let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
//assert (acc == exp_lr_f k a bBits b (i - 1) acc1);
exp_lr_lemma_loop k a bBits b (i - 1);
//assert (acc1 == pow k a (b / pow2 (bBits - i + 1)));
exp_lr_lemma_step #t k a bBits b (i - 1) acc1;
//assert (acc == pow k a (b / pow2 (bBits - i)));
() end
let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul r0' a /\ r0' == pow k a (b / pow2 (bBits - i - 1))))
let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a (b / pow2 (bBits - i) * 2));
if (b / pow2 (bBits - i - 1) % 2 = 0) then begin
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r0);
assert (r1' == mul (mul r0 a) r0);
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 r0;
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
else begin
//assert (r0' == mul r0 r1);
assert (r0' == mul r0 (mul r0 a));
lemma_mul_assoc r0 r0 a;
lemma_pow1 k a;
lemma_pow_add k a (b / pow2 (bBits - i) * 2) 1;
assert (r0' == pow k a (b / pow2 (bBits - i - 1)));
//assert (r1' == mul r1 r1);
assert (r1' == mul (mul r0 a) (mul r0 a));
lemma_mul_comm r0 a;
lemma_mul_assoc a r0 (mul r0 a);
assert (r1' == mul a r0');
lemma_mul_comm a r0';
() end
val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; //mul one r1 == r1
() end
else begin
let (r0', r1') = Loops.repeati (i - 1) (exp_mont_ladder_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_lemma_loop k bBits b a (i - 1);
exp_mont_ladder_lemma_step #t k bBits b a r0' r1' (i - 1);
() end
let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1)
//------------------------------
val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 /\ r1 == r4)
let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
exp_mont_ladder_swap2_lemma_loop k a bBits b (i - 1);
() end
let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits
val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) in
let bit = b / pow2 (bBits - i) % 2 in
sw == bit /\ cswap bit r0 r1 == (r3, r4))
let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap sw0 one a) (i - 1);
exp_mont_ladder_swap_lemma_loop k a bBits b sw0 (i - 1);
() end
let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits
//------------------------------
val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i))
let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
() end
let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b
// Fixed-window method
//---------------------
val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i))
let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc (==) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
(==) { }
k.mul (pow k (pow k a r1) (pow2 l)) (pow k a r2);
(==) { lemma_pow_mul k a r1 (pow2 l) }
k.mul (pow k a (r1 * pow2 l)) (pow k a r2);
(==) { lemma_pow_add k a (r1 * pow2 l) r2 }
pow k a (r1 * pow2 l + r2);
(==) { lemma_b_div_pow2ki bBits b l i }
pow k a (b_acc l bBits b i);
}
val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i))
let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc == exp_fw_f k a bBits b l (i - 1) acc1);
exp_fw_lemma_loop k a bBits b l (i - 1);
exp_fw_lemma_step k a bBits b l i acc1;
() end
val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b / pow2 (bBits / l * l)) (pow2 l);
assert (bits_c == b / pow2 (bBits / l * l));
assert (acc == pow k a (b / pow2 (bBits / l * l)));
()
val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0))
let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp_fw_acc0_lemma #t k a bBits b l
let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l bBits b (bBits / l)));
Math.Lemmas.euclidean_division_definition bBits l;
assert (res == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1)
// Double exponentiation [a1^b1 `mul` a2^b2]
//-------------------------------------------
val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x)
let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
(==) { lemma_pow_add k a (r1 * r3) r2 }
k.mul x (pow k a (r1 * r3 + r2));
(==) { k.lemma_mul_comm x (pow k a (r1 * r3 + r2)) }
k.mul (pow k a (r1 * r3 + r2)) x;
}
val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
mul (pow k a1 (b_acc l bBits b1 i)) (pow k a2 (b_acc l bBits b2 i))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.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": true,
"source_file": "Lib.Exponentiation.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_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"
} | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.pos{i <= bBits / l} ->
acc: t
-> FStar.Pervasives.Lemma
(requires
acc ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k
a1
(Lib.Exponentiation.b_acc l bBits b1 (i - 1)))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 (i - 1))))
(ensures
Lib.Exponentiation.exp_double_fw_f k a1 bBits b1 a2 b2 l (i - 1) acc ==
Lib.Exponentiation.Definition.mul (Lib.Exponentiation.Definition.pow k
a1
(Lib.Exponentiation.b_acc l bBits b1 i))
(Lib.Exponentiation.Definition.pow k a2 (Lib.Exponentiation.b_acc l bBits b2 i))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Prims.squash",
"Lib.Exponentiation.lemma_pow_distr_mul",
"Lib.Exponentiation.lemma_b_div_pow2ki",
"Lib.Exponentiation.exp_pow2_lemma",
"Lib.Exponentiation.Definition.lemma_pow_mul_base",
"Lib.Exponentiation.b_acc",
"FStar.Math.Lemmas.distributivity_sub_right",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Lib.Exponentiation.exp_pow2"
] | [] | false | false | true | false | false | let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
| let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i) in
calc ( == ) {
k.mul acc1 (pow k a2 r22);
( == ) { exp_pow2_lemma k acc l }
k.mul (pow k acc (pow2 l)) (pow k a2 r22);
( == ) { () }
k.mul (pow k (k.mul (pow k a1 r11) (pow k a2 r21)) (pow2 l)) (pow k a2 r22);
( == ) { lemma_pow_mul_base k (pow k a1 r11) (pow k a2 r21) (pow2 l) }
k.mul (k.mul (pow k (pow k a1 r11) (pow2 l)) (pow k (pow k a2 r21) (pow2 l))) (pow k a2 r22);
( == ) { lemma_pow_distr_mul k (pow k (pow k a1 r11) (pow2 l)) a2 r21 r22 (pow2 l) }
k.mul (pow k a2 (r21 * pow2 l + r22)) (pow k (pow k a1 r11) (pow2 l));
( == ) { lemma_b_div_pow2ki bBits b2 l i }
k.mul res_a2 (pow k (pow k a1 r11) (pow2 l));
};
calc ( == ) {
k.mul (k.mul acc1 (pow k a2 r22)) (pow k a1 r12);
( == ) { () }
k.mul (k.mul res_a2 (pow k (pow k a1 r11) (pow2 l))) (pow k a1 r12);
( == ) { lemma_pow_distr_mul k res_a2 a1 r11 r12 (pow2 l) }
k.mul (pow k a1 (r11 * pow2 l + r12)) res_a2;
( == ) { lemma_b_div_pow2ki bBits b1 l i }
k.mul res_a1 res_a2;
} | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptBlockStdcall | val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code | val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code | let va_code_AES128EncryptBlockStdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRdx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRsi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rR8) (va_op_opr64_reg64 rRdx)) (va_CNil ())))) (va_CCons (va_Block
(va_CNil ())) (va_CCons (va_code_AES128EncryptBlock ()) (va_CCons (if win then va_Block
(va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRcx)
(va_op_xmm_xmm 0) 0 Secret) (va_CNil ())) else va_Block (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdi) (va_op_xmm_xmm 0) 0 Secret) (va_CNil
()))) (va_CNil ())))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 639,
"start_col": 0,
"start_line": 629
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ()))))
val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptRound (va_mods:va_mods_t) (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(va_arg5:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 188 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg5) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 189 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` n) Secret keys_buffer n) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 190 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QEmpty (()))))))
val va_lemma_AES128EncryptRound : va_b0:va_code -> va_s0:va_state -> n:nat -> init:quad32 ->
round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptRound n) va_s0 /\ va_get_ok va_s0 /\
(aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <= FStar.Seq.Base.length #quad32
round_keys) /\ va_get_xmm 0 va_s0 == Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\
va_get_reg64 rR8 va_s0 == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.buffer128_read keys_buffer n (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys n))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptRound va_b0 va_s0 n init round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptRound va_mods n init round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptRound n) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 168 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 186 column 53 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <=
FStar.Seq.Base.length #quad32 round_keys) /\ va_get_xmm 0 va_s0 ==
Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\ va_get_reg64 rR8 va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0)
/\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rR8 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer128_read keys_buffer n
(va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #quad32 round_keys n /\ (forall
(va_x_xmm0:quad32) (va_x_xmm2:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n ==> va_k va_sM (())))
val va_wpProof_AES128EncryptRound : n:nat -> init:quad32 -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptRound n init round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptRound n) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptRound n init round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptRound (va_code_AES128EncryptRound n) va_s0 n init
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(va_QProc (va_code_AES128EncryptRound n) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptRound n init round_keys keys_buffer) (va_wpProof_AES128EncryptRound n init
round_keys keys_buffer))
//--
//-- AES128EncryptBlock
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptBlock () =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) 0 Secret) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons (va_code_AES128EncryptRound 1)
(va_CCons (va_code_AES128EncryptRound 2) (va_CCons (va_code_AES128EncryptRound 3) (va_CCons
(va_code_AES128EncryptRound 4) (va_CCons (va_code_AES128EncryptRound 5) (va_CCons
(va_code_AES128EncryptRound 6) (va_CCons (va_code_AES128EncryptRound 7) (va_CCons
(va_code_AES128EncryptRound 8) (va_CCons (va_code_AES128EncryptRound 9) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret) (va_CCons (va_code_AESNI_enc_last (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_CNil
())))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptBlock () =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) 0 Secret) (va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_AES128EncryptRound 1) (va_pbool_and
(va_codegen_success_AES128EncryptRound 2) (va_pbool_and (va_codegen_success_AES128EncryptRound
3) (va_pbool_and (va_codegen_success_AES128EncryptRound 4) (va_pbool_and
(va_codegen_success_AES128EncryptRound 5) (va_pbool_and (va_codegen_success_AES128EncryptRound
6) (va_pbool_and (va_codegen_success_AES128EncryptRound 7) (va_pbool_and
(va_codegen_success_AES128EncryptRound 8) (va_pbool_and (va_codegen_success_AES128EncryptRound
9) (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` 10) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc_last (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_ttrue ())))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptBlock (va_mods:va_mods_t) (input:quad32) (key:(seq nat32))
(round_keys:(seq quad32)) (keys_buffer:buffer128) : (va_quickCode unit
(va_code_AES128EncryptBlock ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 216 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
((fun a_539 (s_540:(FStar.Seq.Base.seq a_539)) (i_541:Prims.nat) -> let (i_515:Prims.nat) =
i_541 in Prims.b2t (Prims.op_LessThan i_515 (FStar.Seq.Base.length #a_539 s_540)))
Vale.Def.Types_s.quad32 round_keys 0) (fun _ -> let (init:Vale.Def.Types_s.quad32) =
Vale.Def.Types_s.quad32_xor input (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys 0)
in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 218 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) 0 Secret keys_buffer 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 219 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 220 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 1 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 221 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 2 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 222 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 3 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 223 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 4 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 224 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 5 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 225 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 6 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 226 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 7 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 227 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 8 init round_keys keys_buffer) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 228 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 9 init round_keys keys_buffer) (fun (va_s:va_state) _ -> let
(va_arg20:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 229 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg20) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 230 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret keys_buffer 10) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 231 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc_last (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 234 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (fun (va_s:va_state) _ -> va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 235 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.aes_encrypt_LE_reveal ()) (va_QEmpty (()))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptBlock va_b0 va_s0 input key round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptBlock va_mods input key round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptBlock ()) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 193 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 214 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptBlock input key round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptBlock (va_code_AES128EncryptBlock ()) va_s0 input key
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptBlockStdcall | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | win: Prims.bool -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.InsBasic.va_code_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Decls.va_code",
"Vale.AES.X64.AES128.va_code_AES128EncryptBlock",
"Vale.X64.InsVector.va_code_Store128_buffer",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi"
] | [] | false | false | false | true | false | let va_code_AES128EncryptBlockStdcall win =
| (va_Block (va_CCons (if win
then
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRdx)
0
Secret)
(va_CNil ()))
else
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRsi)
0
Secret)
(va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64 rR8) (va_op_opr64_reg64 rRdx))
(va_CNil ()))))
(va_CCons (va_Block (va_CNil ()))
(va_CCons (va_code_AES128EncryptBlock ())
(va_CCons (if win
then
va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRcx)
(va_op_xmm_xmm 0)
0
Secret)
(va_CNil ()))
else
va_Block (va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdi)
(va_op_xmm_xmm 0)
0
Secret)
(va_CNil ())))
(va_CNil ())))))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptBlockStdcall | val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool | val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool | let va_codegen_success_AES128EncryptBlockStdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRdx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRsi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rR8) (va_op_opr64_reg64 rRdx)) (va_ttrue ())))
(va_pbool_and (va_codegen_success_AES128EncryptBlock ()) (va_pbool_and (if win then
va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRcx) (va_op_xmm_xmm 0) 0 Secret) (va_ttrue ()) else va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdi)
(va_op_xmm_xmm 0) 0 Secret) (va_ttrue ())) (va_ttrue ())))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 652,
"start_col": 0,
"start_line": 642
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRoundUnrolledRecursive : key:(seq nat32) -> dst:buffer128 -> n:int ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRoundUnrolledRecursive n)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRoundUnrolledRecursive
(va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 key dst n in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int) :
(va_quickCode unit (va_code_KeyExpansionRoundUnrolledRecursive n)) =
(va_QProc (va_code_KeyExpansionRoundUnrolledRecursive n) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm
2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRoundUnrolledRecursive
key dst n) (va_wpProof_KeyExpansionRoundUnrolledRecursive key dst n))
//--
//-- KeyExpansion128Stdcall
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_CNil ())))) (va_CCons
(va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret) (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive 10) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_CNil
()))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRdi) 0 Secret) (va_pbool_and
(va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_ttrue
()))) (va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) 0 Secret) (va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive 10) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_ttrue ())))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansion128Stdcall (va_mods:va_mods_t) (win:bool) (input_key_b:buffer128)
(output_key_expansion_b:buffer128) : (va_quickCode unit (va_code_KeyExpansion128Stdcall win)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s)
(fun _ -> va_get_reg64 rRdi va_s) in let (key_expansion_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRdx va_s) (fun _ -> va_get_reg64
rRsi va_s) in let (key:(FStar.Seq.Base.seq Vale.Def.Words_s.nat32)) =
Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read input_key_b 0 (va_get_mem_heaplet
0 va_s)) in va_QBind va_range1
"***** PRECONDITION NOT MET AT line 143 column 15 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_qInlineIf va_mods win (qblock va_mods (fun (va_s:va_state) -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 145 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRcx) 0 Secret input_key_b 0) (va_QEmpty (())))) (qblock va_mods (fun (va_s:va_state) ->
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 149 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64
rRdi) 0 Secret input_key_b 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 150 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRdx) (va_op_opr64_reg64 rRsi)) (va_QEmpty (()))))))
(fun (va_s:va_state) va_g -> va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 153 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) 0 Secret output_key_expansion_b 0) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 154 column 39 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_KeyExpansionRoundUnrolledRecursive key output_key_expansion_b 10) (fun
(va_s:va_state) _ -> let (va_arg18:(FStar.Seq.Base.seq Vale.Def.Types_s.nat32)) = key in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 155 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_expand_key_128 va_arg18 11) (va_QLemma va_range1
"***** PRECONDITION NOT MET AT line 156 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
true (fun _ -> va_reveal_eq (`%key_to_round_keys_LE) key_to_round_keys_LE key_to_round_keys_LE)
(fun _ -> va_reveal_opaque (`%key_to_round_keys_LE) key_to_round_keys_LE) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 159 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 160 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 161 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 3) (va_op_xmm_xmm 3)) (va_QEmpty (())))))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansion128Stdcall va_b0 va_s0 win input_key_b output_key_expansion_b =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansion128Stdcall va_mods win input_key_b output_key_expansion_b in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansion128Stdcall win) va_qc va_s0
(fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 119 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ (let (key_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0) in let
(key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ -> va_get_reg64
rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 135 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(aesni_enabled /\ avx_enabled /\ sse_enabled) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 136 column 76 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_sM) key_ptr input_key_b 1
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 137 column 98 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) key_expansion_ptr
output_key_expansion_b 11 (va_get_mem_layout va_sM) Secret)) /\ (let (key_ptr:(va_int_range 0
18446744073709551615)) = va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64
rRdi va_s0) in let (key_expansion_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _
-> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0) in let (key:(FStar.Seq.Base.seq
Vale.Def.Words_s.nat32)) = Vale.Arch.Types.quad32_to_seq (Vale.X64.Decls.buffer128_read
input_key_b 0 (va_get_mem_heaplet 0 va_s0)) in label va_range1
"***** POSTCONDITION NOT MET AT line 139 column 70 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer128 output_key_expansion_b (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 141 column 109 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(forall j . {:pattern(buffer128_read output_key_expansion_b j (va_get_mem_heaplet 1 va_sM))}0
<= j /\ j <= 10 ==> Vale.X64.Decls.buffer128_read output_key_expansion_b j (va_get_mem_heaplet
1 va_sM) == FStar.Seq.Base.index #Vale.Def.Types_s.quad32 (Vale.AES.AES_s.key_to_round_keys_LE
AES_128 key) j))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_KeyExpansion128Stdcall win input_key_b output_key_expansion_b va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansion128Stdcall (va_code_KeyExpansion128Stdcall win) va_s0
win input_key_b output_key_expansion_b in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rRdx va_sM (va_update_ok
va_sM (va_update_mem va_sM va_s0)))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_reg64 rRdx; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptRound
val va_code_AES128EncryptRound : n:nat -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ()))))
val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ())))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptRound (va_mods:va_mods_t) (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in let
(va_arg5:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 188 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg5) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 189 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` n) Secret keys_buffer n) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 190 column 14 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QEmpty (()))))))
val va_lemma_AES128EncryptRound : va_b0:va_code -> va_s0:va_state -> n:nat -> init:quad32 ->
round_keys:(seq quad32) -> keys_buffer:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_AES128EncryptRound n) va_s0 /\ va_get_ok va_s0 /\
(aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <= FStar.Seq.Base.length #quad32
round_keys) /\ va_get_xmm 0 va_s0 == Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\
va_get_reg64 rR8 va_s0 == Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer
(va_get_mem_heaplet 0 va_s0) /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0)
(va_get_reg64 rR8 va_s0) keys_buffer 11 (va_get_mem_layout va_s0) Secret /\
Vale.X64.Decls.buffer128_read keys_buffer n (va_get_mem_heaplet 0 va_s0) ==
FStar.Seq.Base.index #quad32 round_keys n))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM (va_update_ok va_sM
va_s0))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptRound va_b0 va_s0 n init round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptRound va_mods n init round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptRound n) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 168 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 186 column 53 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (aesni_enabled /\ sse_enabled) /\ (1 <= n /\ n < 10 /\ 10 <=
FStar.Seq.Base.length #quad32 round_keys) /\ va_get_xmm 0 va_s0 ==
Vale.AES.AES_s.eval_rounds_def init round_keys (n - 1) /\ va_get_reg64 rR8 va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 keys_buffer (va_get_mem_heaplet 0 va_s0)
/\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem_heaplet 0 va_s0) (va_get_reg64 rR8 va_s0)
keys_buffer 11 (va_get_mem_layout va_s0) Secret /\ Vale.X64.Decls.buffer128_read keys_buffer n
(va_get_mem_heaplet 0 va_s0) == FStar.Seq.Base.index #quad32 round_keys n /\ (forall
(va_x_xmm0:quad32) (va_x_xmm2:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags
va_x_efl (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 0 va_x_xmm0 va_s0)) in va_get_ok va_sM /\
va_get_xmm 0 va_sM == Vale.AES.AES_s.eval_rounds_def init round_keys n ==> va_k va_sM (())))
val va_wpProof_AES128EncryptRound : n:nat -> init:quad32 -> round_keys:(seq quad32) ->
keys_buffer:buffer128 -> va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_AES128EncryptRound n init round_keys keys_buffer va_s0
va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_AES128EncryptRound n) ([va_Mod_flags;
va_Mod_xmm 2; va_Mod_xmm 0]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptRound n init round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptRound (va_code_AES128EncryptRound n) va_s0 n init
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_AES128EncryptRound (n:nat) (init:quad32) (round_keys:(seq quad32))
(keys_buffer:buffer128) : (va_quickCode unit (va_code_AES128EncryptRound n)) =
(va_QProc (va_code_AES128EncryptRound n) ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0])
(va_wp_AES128EncryptRound n init round_keys keys_buffer) (va_wpProof_AES128EncryptRound n init
round_keys keys_buffer))
//--
//-- AES128EncryptBlock
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptBlock () =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) 0 Secret) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons (va_code_AES128EncryptRound 1)
(va_CCons (va_code_AES128EncryptRound 2) (va_CCons (va_code_AES128EncryptRound 3) (va_CCons
(va_code_AES128EncryptRound 4) (va_CCons (va_code_AES128EncryptRound 5) (va_CCons
(va_code_AES128EncryptRound 6) (va_CCons (va_code_AES128EncryptRound 7) (va_CCons
(va_code_AES128EncryptRound 8) (va_CCons (va_code_AES128EncryptRound 9) (va_CCons
(va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret) (va_CCons (va_code_AESNI_enc_last (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_CNil
())))))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_AES128EncryptBlock () =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) 0 Secret) (va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_AES128EncryptRound 1) (va_pbool_and
(va_codegen_success_AES128EncryptRound 2) (va_pbool_and (va_codegen_success_AES128EncryptRound
3) (va_pbool_and (va_codegen_success_AES128EncryptRound 4) (va_pbool_and
(va_codegen_success_AES128EncryptRound 5) (va_pbool_and (va_codegen_success_AES128EncryptRound
6) (va_pbool_and (va_codegen_success_AES128EncryptRound 7) (va_pbool_and
(va_codegen_success_AES128EncryptRound 8) (va_pbool_and (va_codegen_success_AES128EncryptRound
9) (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` 10) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc_last (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (va_ttrue ())))))))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_AES128EncryptBlock (va_mods:va_mods_t) (input:quad32) (key:(seq nat32))
(round_keys:(seq quad32)) (keys_buffer:buffer128) : (va_quickCode unit
(va_code_AES128EncryptBlock ())) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_qAssertSquash
va_range1
"***** EXPRESSION PRECONDITIONS NOT MET WITHIN line 216 column 5 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
((fun a_539 (s_540:(FStar.Seq.Base.seq a_539)) (i_541:Prims.nat) -> let (i_515:Prims.nat) =
i_541 in Prims.b2t (Prims.op_LessThan i_515 (FStar.Seq.Base.length #a_539 s_540)))
Vale.Def.Types_s.quad32 round_keys 0) (fun _ -> let (init:Vale.Def.Types_s.quad32) =
Vale.Def.Types_s.quad32_xor input (FStar.Seq.Base.index #Vale.Def.Types_s.quad32 round_keys 0)
in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 218 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) 0 Secret keys_buffer 0) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 219 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 220 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 1 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 221 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 2 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 222 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 3 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 223 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 4 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 224 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 5 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 225 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 6 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 226 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 7 init round_keys keys_buffer) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 227 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 8 init round_keys keys_buffer) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 228 column 23 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AES128EncryptRound 9 init round_keys keys_buffer) (fun (va_s:va_state) _ -> let
(va_arg20:Vale.Def.Types_s.quad32) = va_get_xmm 0 va_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 229 column 33 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.commute_sub_bytes_shift_rows va_arg20) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 230 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64
rR8) (16 `op_Multiply` 10) Secret keys_buffer 10) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 231 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_enc_last (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 234 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 2) (va_op_xmm_xmm 2)) (fun (va_s:va_state) _ -> va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 235 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_s.aes_encrypt_LE_reveal ()) (va_QEmpty (()))))))))))))))))))))
[@"opaque_to_smt"]
let va_lemma_AES128EncryptBlock va_b0 va_s0 input key round_keys keys_buffer =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok] in
let va_qc = va_qcode_AES128EncryptBlock va_mods input key round_keys keys_buffer in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_AES128EncryptBlock ()) va_qc va_s0 (fun
va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 193 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 214 column 52 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 0 va_sM == Vale.AES.AES_s.aes_encrypt_LE AES_128 key input)) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0; va_Mod_ok]) va_sM va_s0;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_AES128EncryptBlock input key round_keys keys_buffer va_s0 va_k =
let (va_sM, va_f0) = va_lemma_AES128EncryptBlock (va_code_AES128EncryptBlock ()) va_s0 input key
round_keys keys_buffer in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 2 va_sM (va_update_xmm 0 va_sM
(va_update_ok va_sM va_s0)))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 2; va_Mod_xmm 0]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- AES128EncryptBlockStdcall
[@ "opaque_to_smt" va_qattr]
let va_code_AES128EncryptBlockStdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRdx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRsi) 0 Secret) (va_CCons (va_code_Mov64
(va_op_dst_opr64_reg64 rR8) (va_op_opr64_reg64 rRdx)) (va_CNil ())))) (va_CCons (va_Block
(va_CNil ())) (va_CCons (va_code_AES128EncryptBlock ()) (va_CCons (if win then va_Block
(va_CCons (va_code_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRcx)
(va_op_xmm_xmm 0) 0 Secret) (va_CNil ())) else va_Block (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdi) (va_op_xmm_xmm 0) 0 Secret) (va_CNil
()))) (va_CNil ())))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | win: Prims.bool -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.InsBasic.va_codegen_success_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Decls.va_pbool",
"Vale.AES.X64.AES128.va_codegen_success_AES128EncryptBlock",
"Vale.X64.InsVector.va_codegen_success_Store128_buffer",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi"
] | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptBlockStdcall win =
| (va_pbool_and (if win
then
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRdx)
0
Secret)
(va_ttrue ())
else
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRsi)
0
Secret)
(va_pbool_and (va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rR8)
(va_op_opr64_reg64 rRdx))
(va_ttrue ())))
(va_pbool_and (va_codegen_success_AES128EncryptBlock ())
(va_pbool_and (if win
then
va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRcx)
(va_op_xmm_xmm 0)
0
Secret)
(va_ttrue ())
else
va_pbool_and (va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1)
(va_op_reg_opr64_reg64 rRdi)
(va_op_xmm_xmm 0)
0
Secret)
(va_ttrue ()))
(va_ttrue ())))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wp_KeyExpansionRound | val va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 143,
"start_col": 0,
"start_line": 128
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.validDstAddrs128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Vale.Def.Words_s.pow2_8",
"Vale.Def.Words_s.pow2_32",
"Vale.AES.AES_common_s.aes_rcon",
"Vale.AES.AES_s.is_aes_key_LE",
"Vale.AES.AES_common_s.AES_128",
"Vale.Def.Types_s.quad32",
"Vale.X64.Decls.va_get_xmm",
"Vale.AES.AES_helpers.expand_key_128",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Decls.quad32",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.X64.Decls.buffer128_read",
"Prims.op_Addition",
"Vale.X64.Decls.modifies_buffer_specific128",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg64 rRdx va_s0)
dst
11
(va_get_mem_layout va_s0)
Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <= round /\ round < 10) /\
rcon == Vale.AES.AES_common_s.aes_rcon round /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
va_get_xmm 1 va_s0 == Vale.AES.AES_helpers.expand_key_128 key round /\
(forall (va_x_mem: vale_heap)
(va_x_heap1: vale_heap)
(va_x_xmm1: quad32)
(va_x_xmm2: quad32)
(va_x_xmm3: quad32)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_xmm 3
va_x_xmm3
(va_upd_xmm 2
va_x_xmm2
(va_upd_xmm 1
va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem va_x_mem va_s0)))))
in
va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM)
(va_get_reg64 rRdx va_sM)
dst
11
(va_get_mem_layout va_sM)
Secret /\
va_get_xmm 1 va_sM ==
Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\
va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM)
(round + 1)
(round + 1) ==>
va_k va_sM (()))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_quick_KeyExpansionRound | val va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | val va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key)) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 171,
"start_col": 0,
"start_line": 167
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.AES128.va_code_KeyExpansionRound round rcon) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.X64.AES128.va_wp_KeyExpansionRound",
"Vale.AES.X64.AES128.va_wpProof_KeyExpansionRound",
"Vale.X64.QuickCode.va_quickCode"
] | [] | false | false | false | false | false | let va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
| (va_QProc (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key)) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_qcode_KeyExpansionRound | val va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | val va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (()))))))))))))))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 97,
"end_line": 81,
"start_col": 0,
"start_line": 51
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ()))))))))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
va_mods: Vale.X64.QuickCode.va_mods_t ->
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.AES128.va_code_KeyExpansionRound round rcon) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.va_mods_t",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCodes.qblock",
"Prims.unit",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.InsAes.va_code_AESNI_keygen_assist",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.InsVector.va_code_Pshufd",
"Vale.X64.InsVector.va_code_VPslldq4",
"Vale.X64.InsVector.va_code_Pxor",
"Vale.X64.InsVector.va_code_Store128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.op_Multiply",
"Prims.op_Addition",
"Vale.Arch.HeapTypes_s.Secret",
"Prims.Nil",
"Vale.X64.Machine_s.precode",
"Vale.X64.Decls.ins",
"Vale.X64.Decls.ocmp",
"Vale.X64.Decls.va_state",
"Vale.X64.QuickCodes.va_QSeq",
"Vale.X64.QuickCodes.va_range1",
"Vale.X64.InsAes.va_quick_AESNI_keygen_assist",
"Vale.X64.InsVector.va_quick_Pshufd",
"Vale.X64.InsVector.va_quick_VPslldq4",
"Vale.X64.InsVector.va_quick_Pxor",
"Vale.X64.QuickCodes.va_QBind",
"Vale.X64.InsVector.va_quick_Store128_buffer",
"Vale.X64.QuickCodes.va_qPURE",
"Prims.pure_post",
"Prims.l_and",
"Prims.l_True",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_helpers.simd_round_key_128",
"Vale.AES.AES_helpers.round_key_128_rcon",
"Vale.AES.AES_helpers.lemma_simd_round_key",
"Vale.Def.Words_s.nat32",
"Prims.nat",
"Vale.AES.AES_s.is_aes_key_LE",
"Vale.AES.AES_common_s.AES_128",
"Vale.AES.AES_helpers.expand_key_128",
"Vale.AES.AES_helpers.expand_key_128_def",
"Vale.AES.AES_helpers.expand_key_128_reveal",
"Vale.X64.QuickCodes.va_QEmpty",
"Vale.X64.Decls.va_get_xmm",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.State.vale_state",
"Vale.X64.QuickCode.va_quickCode",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound"
] | [] | false | false | false | false | false | let va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
| (qblock va_mods
(fun (va_s: va_state) ->
let va_old_s:va_state = va_s in
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255)
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2))
(va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1
)
(va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1)
(16 `op_Multiply` (round + 1))
Secret
dst
(round + 1))
(fun (va_s: va_state) _ ->
let va_arg15:Vale.Def.Types_s.nat32 = rcon in
let va_arg14:Vale.Def.Types_s.quad32 =
va_get_xmm 1 va_old_s
in
va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_: unit) ->
Vale.AES.AES_helpers.lemma_simd_round_key va_arg14
va_arg15)
(va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_: unit) ->
Vale.AES.AES_helpers.expand_key_128_reveal
())
(va_QEmpty (()))))))))))))))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wpProof_KeyExpansionRound | val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g)))) | val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g)))) | let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 164,
"start_col": 0,
"start_line": 154
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g)))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.Decls.va_fuel) * Prims.unit) | Prims.Ghost | [] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Prims._assert",
"Vale.X64.Decls.va_state_eq",
"Vale.X64.Decls.va_update_flags",
"Vale.X64.Decls.va_update_xmm",
"Vale.X64.Decls.va_update_mem_heaplet",
"Vale.X64.Decls.va_update_ok",
"Vale.X64.Decls.va_update_mem",
"Vale.X64.Decls.va_lemma_upd_update",
"FStar.Pervasives.Native.tuple3",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.State.vale_state",
"Vale.AES.X64.AES128.va_lemma_KeyExpansionRound",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound"
] | [] | false | false | false | false | false | let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
| let va_sM, va_f0 =
va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0 round rcon dst key
in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM
(va_update_xmm 3
va_sM
(va_update_xmm 2
va_sM
(va_update_xmm 1
va_sM
(va_update_mem_heaplet 1
va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0))))))));
va_lemma_norm_mods ([
va_Mod_flags;
va_Mod_xmm 3;
va_Mod_xmm 2;
va_Mod_xmm 1;
va_Mod_mem_heaplet 1;
va_Mod_mem
])
va_sM
va_s0;
let va_g = () in
(va_sM, va_f0, va_g) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wp_KeyExpansionRoundUnrolledRecursive | val va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem:vale_heap) (va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm
3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1
(va_upd_mem va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128
(va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret
/\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet 1
va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1
va_sM) /\ (forall j . {:pattern(buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}0 <= j /\ j
<= n ==> Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==> va_k va_sM (()))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 265,
"start_col": 0,
"start_line": 248
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n])
[@ "opaque_to_smt"]
let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ())))
val va_codegen_success_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_pbool(decreases %[n])
[@ "opaque_to_smt"]
let rec va_codegen_success_KeyExpansionRoundUnrolledRecursive n =
(va_pbool_and (if (0 < n && n <= 10) then va_pbool_and
(va_codegen_success_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_pbool_and
(va_codegen_success_KeyExpansionRound (n - 1) (Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_ttrue ())) else va_ttrue ()) (va_ttrue ()))
val va_lemma_KeyExpansionRoundUnrolledRecursive : va_b0:va_code -> va_s0:va_state -> key:(seq
nat32) -> dst:buffer128 -> n:int
-> Ghost (va_state & va_fuel)(decreases %[n])
(requires (va_require_total va_b0 (va_code_KeyExpansionRoundUnrolledRecursive n) va_s0 /\
va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= n /\ n <= 10) /\ Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ key ==
Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\ va_get_xmm 1 va_s0 ==
Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\ va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ Vale.X64.Decls.modifies_buffer128 dst (va_get_mem_heaplet 1
va_s0) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
n (va_get_mem_heaplet 1 va_sM) /\ (forall j . {:pattern(buffer128_read dst j
(va_get_mem_heaplet 1 va_sM))}0 <= j /\ j <= n ==> Vale.X64.Decls.buffer128_read dst j
(va_get_mem_heaplet 1 va_sM) == Vale.AES.AES_helpers.expand_key_128 key j) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM
(va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let rec va_lemma_KeyExpansionRoundUnrolledRecursive va_b0 va_s0 key dst n =
va_reveal_opaque (`%va_code_KeyExpansionRoundUnrolledRecursive)
(va_code_KeyExpansionRoundUnrolledRecursive n);
let (va_old_s:va_state) = va_s0 in
let (va_b1:va_codes) = va_get_block va_b0 in
Vale.AES.AES_helpers.expand_key_128_reveal ();
let va_b3 = va_tl va_b1 in
let va_c3 = va_hd va_b1 in
let (va_fc3, va_s3) =
(
if (0 < n && n <= 10) then
(
let va_b4 = va_get_block va_c3 in
let (va_s5, va_fc5) = va_lemma_KeyExpansionRoundUnrolledRecursive (va_hd va_b4) va_s0 key dst
(n - 1) in
let va_b5 = va_tl va_b4 in
let (va_s6, va_fc6) = va_lemma_KeyExpansionRound (va_hd va_b5) va_s5 (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)) dst key in
let va_b6 = va_tl va_b5 in
let (va_s3, va_f6) = va_lemma_empty_total va_s6 va_b6 in
let va_f5 = va_lemma_merge_total va_b5 va_s5 va_fc6 va_s6 va_f6 va_s3 in
let va_fc3 = va_lemma_merge_total va_b4 va_s0 va_fc5 va_s5 va_f5 va_s3 in
(va_fc3, va_s3)
)
else
(
let va_b7 = va_get_block va_c3 in
let (va_s3, va_fc3) = va_lemma_empty_total va_s0 va_b7 in
(va_fc3, va_s3)
)
) in
let (va_sM, va_f3) = va_lemma_empty_total va_s3 va_b3 in
let va_fM = va_lemma_merge_total va_b1 va_s0 va_fc3 va_s3 va_f3 va_sM in
(va_sM, va_fM) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
dst: Vale.X64.Memory.buffer128 ->
n: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.validDstAddrs128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Decls.va_get_mem_layout",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.op_LessThanOrEqual",
"Vale.AES.AES_s.is_aes_key_LE",
"Vale.AES.AES_common_s.AES_128",
"Prims.eq2",
"Vale.Arch.Types.quad32_to_seq",
"Vale.X64.Decls.va_get_xmm",
"Vale.X64.Decls.quad32",
"Vale.X64.Decls.buffer128_read",
"Vale.X64.Memory.buffer_addr",
"Vale.X64.Memory.vuint128",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.X64.Decls.modifies_buffer128",
"Prims.op_GreaterThanOrEqual",
"Vale.Def.Types_s.quad32",
"Vale.AES.AES_helpers.expand_key_128",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_mem"
] | [] | false | false | false | true | true | let va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg64 rRdx va_s0)
dst
11
(va_get_mem_layout va_s0)
Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <= n /\ n <= 10) /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
key == Vale.Arch.Types.quad32_to_seq (va_get_xmm 1 va_s0) /\
va_get_xmm 1 va_s0 == Vale.X64.Decls.buffer128_read dst 0 (va_get_mem_heaplet 1 va_s0) /\
va_get_reg64 rRdx va_s0 ==
Vale.X64.Memory.buffer_addr #Vale.X64.Memory.vuint128 dst (va_get_mem_heaplet 1 va_s0) /\
(forall (va_x_mem: vale_heap)
(va_x_heap1: vale_heap)
(va_x_xmm1: quad32)
(va_x_xmm2: quad32)
(va_x_xmm3: quad32)
(va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_xmm 3
va_x_xmm3
(va_upd_xmm 2
va_x_xmm2
(va_upd_xmm 1
va_x_xmm1
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem va_x_mem va_s0)))))
in
va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM)
(va_get_reg64 rRdx va_sM)
dst
11
(va_get_mem_layout va_sM)
Secret /\
Vale.X64.Decls.modifies_buffer128 dst
(va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) /\
va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst n (va_get_mem_heaplet 1 va_sM) /\
(forall j. {:pattern (buffer128_read dst j (va_get_mem_heaplet 1 va_sM))}
0 <= j /\ j <= n ==>
Vale.X64.Decls.buffer128_read dst j (va_get_mem_heaplet 1 va_sM) ==
Vale.AES.AES_helpers.expand_key_128 key j) ==>
va_k va_sM (()))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansionRoundUnrolledRecursive | val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n]) | val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n]) | let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(va_CNil ()))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 181,
"start_col": 0,
"start_line": 177
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.Arch.Types
open Vale.AES.AES_helpers
open Vale.X64.CPU_Features_s
#reset-options "--z3rlimit 20"
//-- KeyExpansionRound
val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code
[@ "opaque_to_smt" va_qattr]
let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm
3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor
(va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3)
(va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_CCons (va_code_Store128_buffer
(va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx) (va_op_xmm_xmm 1) (16 `op_Multiply`
(round + 1)) Secret) (va_CNil ()))))))))))))
val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_pbool_and
(va_codegen_success_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_pbool_and
(va_codegen_success_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret) (va_ttrue ())))))))))))
[@ "opaque_to_smt" va_qattr]
let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 71 column 11 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 72 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 73 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 74 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 75 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 76 column 13 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 77 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 78 column 9 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 2)) (va_QBind va_range1
"***** PRECONDITION NOT MET AT line 79 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_Store128_buffer (va_op_heaplet_mem_heaplet 1) (va_op_reg_opr64_reg64 rRdx)
(va_op_xmm_xmm 1) (16 `op_Multiply` (round + 1)) Secret dst (round + 1)) (fun (va_s:va_state) _
-> let (va_arg15:Vale.Def.Types_s.nat32) = rcon in let (va_arg14:Vale.Def.Types_s.quad32) =
va_get_xmm 1 va_old_s in va_qPURE va_range1
"***** PRECONDITION NOT MET AT line 82 column 25 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.lemma_simd_round_key va_arg14 va_arg15) (va_qPURE
va_range1
"***** PRECONDITION NOT MET AT line 83 column 26 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(fun (_:unit) -> Vale.AES.AES_helpers.expand_key_128_reveal ()) (va_QEmpty (())))))))))))))))
val va_lemma_KeyExpansionRound : va_b0:va_code -> va_s0:va_state -> round:nat64 -> rcon:nat8 ->
dst:buffer128 -> key:(seq nat32)
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_KeyExpansionRound round rcon) va_s0 /\ va_get_ok va_s0
/\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64 rRdx va_s0) dst
11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <=
round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst
(round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1 va_sM ==
Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3
va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM
(va_update_ok va_sM (va_update_mem va_sM va_s0)))))))))
[@"opaque_to_smt"]
let va_lemma_KeyExpansionRound va_b0 va_s0 round rcon dst key =
let (va_mods:va_mods_t) = [va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1;
va_Mod_mem_heaplet 1; va_Mod_ok; va_Mod_mem] in
let va_qc = va_qcode_KeyExpansionRound va_mods round rcon dst key in
let (va_sM, va_fM, va_g) = va_wp_sound_code_norm (va_code_KeyExpansionRound round rcon) va_qc
va_s0 (fun va_s0 va_sM va_g -> let () = va_g in label va_range1
"***** POSTCONDITION NOT MET AT line 47 column 1 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_ok va_sM) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 58 column 65 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_sM) (va_get_reg64 rRdx va_sM) dst 11
(va_get_mem_layout va_sM) Secret) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 66 column 54 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1
va_sM)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 67 column 47 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_get_xmm 1 va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1)) /\ label va_range1
"***** POSTCONDITION NOT MET AT line 68 column 82 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0)
(va_get_mem_heaplet 1 va_sM) (round + 1) (round + 1))) in
assert_norm (va_qc.mods == va_mods);
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_ok; va_Mod_mem]) va_sM va_s0;
(va_sM, va_fM)
[@ va_qattr]
let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabled /\ avx_enabled /\
sse_enabled) /\ (0 <= round /\ round < 10) /\ rcon == Vale.AES.AES_common_s.aes_rcon round /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\ va_get_xmm 1 va_s0 ==
Vale.AES.AES_helpers.expand_key_128 key round /\ (forall (va_x_mem:vale_heap)
(va_x_heap1:vale_heap) (va_x_xmm1:quad32) (va_x_xmm2:quad32) (va_x_xmm3:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 3 va_x_xmm3
(va_upd_xmm 2 va_x_xmm2 (va_upd_xmm 1 va_x_xmm1 (va_upd_mem_heaplet 1 va_x_heap1 (va_upd_mem
va_x_mem va_s0))))) in va_get_ok va_sM /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1
va_sM) (va_get_reg64 rRdx va_sM) dst 11 (va_get_mem_layout va_sM) Secret /\ va_get_xmm 1 va_sM
== Vale.X64.Decls.buffer128_read dst (round + 1) (va_get_mem_heaplet 1 va_sM) /\ va_get_xmm 1
va_sM == Vale.AES.AES_helpers.expand_key_128 key (round + 1) /\
Vale.X64.Decls.modifies_buffer_specific128 dst (va_get_mem_heaplet 1 va_s0) (va_get_mem_heaplet
1 va_sM) (round + 1) (round + 1) ==> va_k va_sM (())))
val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
va_s0 va_k ((va_sM, va_f0, va_g))))
[@"opaque_to_smt"]
let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_update_xmm 1 va_sM (va_update_mem_heaplet 1 va_sM (va_update_ok va_sM (va_update_mem va_sM
va_s0))))))));
va_lemma_norm_mods ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet
1; va_Mod_mem]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
[@ "opaque_to_smt" va_qattr]
let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key))
//--
//-- KeyExpansionRoundUnrolledRecursive
val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n]) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.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.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_helpers.fsti.checked",
"Vale.AES.AES_common_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.AES.X64.AES128.fst"
} | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"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.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Opaque_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
}
] | {
"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": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | n: Prims.int -> Prims.Tot Vale.X64.Decls.va_code | Prims.Tot | [
"total",
""
] | [] | [
"Prims.int",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Vale.AES.X64.AES128.va_code_KeyExpansionRoundUnrolledRecursive",
"Prims.op_Subtraction",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound",
"Vale.AES.AES_common_s.aes_rcon",
"Vale.X64.Decls.va_CNil",
"Prims.bool",
"Vale.X64.Decls.va_code"
] | [
"recursion"
] | false | false | false | true | false | let rec va_code_KeyExpansionRoundUnrolledRecursive n =
| (va_Block (va_CCons (if (0 < n && n <= 10)
then
va_Block (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive (n - 1))
(va_CCons (va_code_KeyExpansionRound (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_CNil ())))
else va_Block (va_CNil ()))
(va_CNil ()))) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.