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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
SelectorsLList3Example.fst | SelectorsLList3Example.data | val data (c: cell) : a | val data (c: cell) : a | let data (c:cell) : a = LL.data c | {
"file_name": "share/steel/examples/steel/llist3/SelectorsLList3Example.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 33,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module SelectorsLList3Example
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.ArrayRef
module L = FStar.List.Tot
module LL = Selectors.LList3
module U32 = FStar.UInt32
module MB = LowStar.Monotonic.Buffer // for is_null
inline_for_extraction noextract let a = U32.t
let cell = LL.cell a
/// The type of a list: A reference to a cell
let t = LL.t a | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"Steel.ArrayRef.fsti.checked",
"Selectors.LList3.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "SelectorsLList3Example.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer // for is_null",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Selectors.LList3",
"short_module": "LL"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.ArrayRef",
"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.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 | c: SelectorsLList3Example.cell -> SelectorsLList3Example.a | Prims.Tot | [
"total"
] | [] | [
"SelectorsLList3Example.cell",
"Selectors.LList3.data",
"SelectorsLList3Example.a"
] | [] | false | false | false | true | false | let data (c: cell) : a =
| LL.data c | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose8x8_1 | val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t | val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t | let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7') | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 73,
"start_col": 0,
"start_line": 64
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | _: Lib.IntVector.Transpose.vec_t8 t -> Lib.IntVector.Transpose.vec_t8 t | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.IntVector.Transpose.vec_t8",
"Lib.IntVector.vec_t",
"FStar.Pervasives.Native.Mktuple8",
"Lib.IntVector.vec_interleave_high_n",
"Lib.IntVector.vec_interleave_low_n"
] | [] | false | false | false | false | false | let transpose8x8_1 #t (v0, v1, v2, v3, v4, v5, v6, v7) =
| let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0', v1', v2', v3', v4', v5', v6', v7') | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_uint | val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len | val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len | let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 12,
"end_line": 17,
"start_col": 0,
"start_line": 15
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_pos -> x: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.op_String_Assignment",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Definitions.lbignum"
] | [] | false | false | false | false | false | let bn_from_uint #t len x =
| let b = create len (uint #t 0) in
b.[ 0 ] <- x | false |
Steel.ST.Array.fst | Steel.ST.Array.share | val share
(#opened: _)
(#elt: Type)
(#x: Seq.seq elt)
(a: array elt)
(p p1 p2: P.perm)
: STGhost unit opened
(pts_to a p x)
(fun _ -> pts_to a p1 x `star` pts_to a p2 x)
(p == p1 `P.sum_perm` p2)
(fun _ -> True) | val share
(#opened: _)
(#elt: Type)
(#x: Seq.seq elt)
(a: array elt)
(p p1 p2: P.perm)
: STGhost unit opened
(pts_to a p x)
(fun _ -> pts_to a p1 x `star` pts_to a p2 x)
(p == p1 `P.sum_perm` p2)
(fun _ -> True) | let share
#_ #_ #x a p p1 p2
= rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite
(H.pts_to a p1 _)
(pts_to a p1 x);
rewrite
(H.pts_to a p2 _)
(pts_to a p2 x) | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 19,
"end_line": 152,
"start_col": 0,
"start_line": 141
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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.ST.Array
module US = FStar.SizeT
/// Lifting a value of universe 0 to universe 1. We use
/// FStar.Universe, since FStar.Extraction.Krml is set to extract
/// those functions to identity.
inline_for_extraction
[@@ noextract_to "krml"]
let raise_t (t: Type0) : Type u#1 = FStar.Universe.raise_t t
inline_for_extraction
[@@noextract_to "krml"]
let raise (#t: Type) (x: t) : Tot (raise_t t) =
FStar.Universe.raise_val x
inline_for_extraction
[@@noextract_to "krml"]
let lower (#t: Type) (x: raise_t t) : Tot t =
FStar.Universe.downgrade_val x
/// A map operation on sequences. Here we only need Ghost versions,
/// because such sequences are only used in vprops or with their
/// selectors.
let rec seq_map
(#t: Type u#a)
(#t' : Type u#b)
(f: (t -> GTot t'))
(s: Seq.seq t)
: Ghost (Seq.seq t')
(requires True)
(ensures (fun s' ->
Seq.length s' == Seq.length s /\
(forall i . {:pattern (Seq.index s' i)} Seq.index s' i == f (Seq.index s i))
))
(decreases (Seq.length s))
= if Seq.length s = 0
then Seq.empty
else Seq.cons (f (Seq.index s 0)) (seq_map f (Seq.slice s 1 (Seq.length s)))
let seq_map_append
(#t: Type u#a)
(#t': Type u#b)
(f: (t -> GTot t'))
(s1 s2: Seq.seq t)
: Lemma
(seq_map f (s1 `Seq.append` s2) `Seq.equal` (seq_map f s1 `Seq.append` seq_map f s2))
= ()
let seq_map_raise_inj
(#elt: Type0)
(s1 s2: Seq.seq elt)
: Lemma
(requires (seq_map raise s1 == seq_map raise s2))
(ensures (s1 == s2))
[SMTPat (seq_map raise s1); SMTPat (seq_map raise s2)]
= assert (seq_map lower (seq_map raise s1) `Seq.equal` s1);
assert (seq_map lower (seq_map raise s2) `Seq.equal` s2)
/// Implementation of the interface
/// base, ptr, array, pts_to
module H = Steel.ST.HigherArray
let base_t elt = H.base_t (raise_t elt)
let base_len b = H.base_len b
let ptr elt = H.ptr (raise_t elt)
let null_ptr elt = H.null_ptr (raise_t elt)
let is_null_ptr p = H.is_null_ptr p
let base p = H.base p
let offset p = H.offset p
let ptr_base_offset_inj p1 p2 = H.ptr_base_offset_inj p1 p2
let base_len_null_ptr elt = H.base_len_null_ptr (raise_t elt)
let length_fits a = H.length_fits a
let pts_to a p s = H.pts_to a p (seq_map raise s)
let pts_to_length a s =
H.pts_to_length a _
let h_array_eq'
(#t: Type u#1)
(a1 a2: H.array t)
: Lemma
(requires (
dfst a1 == dfst a2 /\
(Ghost.reveal (dsnd a1) <: nat) == Ghost.reveal (dsnd a2)
))
(ensures (
a1 == a2
))
= ()
let pts_to_not_null #_ #t #p a s =
let _ = H.pts_to_not_null #_ #_ #p a (seq_map raise s) in
assert (a =!= H.null #(raise_t t));
Classical.move_requires (h_array_eq' a) (H.null #(raise_t t));
noop ()
let pts_to_inj a p1 s1 p2 s2 =
H.pts_to_inj a p1 (seq_map raise s1) p2 (seq_map raise s2)
/// Non-selector operations.
let malloc x n =
let res = H.malloc (raise x) n in
assert (seq_map raise (Seq.create (US.v n) x) `Seq.equal` Seq.create (US.v n) (raise x));
rewrite
(H.pts_to res _ _)
(pts_to res _ _);
return res
let free #_ x =
let s = elim_exists () in
rewrite
(pts_to x _ _)
(H.pts_to x P.full_perm (seq_map raise s));
H.free x | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.Array.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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 |
a: Steel.ST.Array.array elt ->
p: Steel.FractionalPermission.perm ->
p1: Steel.FractionalPermission.perm ->
p2: Steel.FractionalPermission.perm
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"FStar.Seq.Base.seq",
"Steel.ST.Array.array",
"Steel.FractionalPermission.perm",
"Steel.ST.Util.rewrite",
"Steel.ST.HigherArray.pts_to",
"Steel.ST.Array.raise_t",
"Steel.ST.Array.seq_map",
"Steel.ST.Array.raise",
"Steel.ST.Array.pts_to",
"Prims.unit",
"Steel.ST.HigherArray.share"
] | [] | false | true | false | false | false | let share #_ #_ #x a p p1 p2 =
| rewrite (pts_to a _ _) (H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite (H.pts_to a p1 _) (pts_to a p1 x);
rewrite (H.pts_to a p2 _) (pts_to a p2 x) | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.point_eval | val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point | val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point | let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 28,
"start_col": 0,
"start_line": 23
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.Ed25519.Field51.point
-> Prims.GTot Spec.Ed25519.PointOps.ext_point | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.point",
"FStar.Pervasives.Native.Mktuple4",
"Spec.Curve25519.elem",
"Hacl.Impl.Ed25519.Field51.fevalh",
"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.gsub",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Spec.Ed25519.PointOps.ext_point"
] | [] | false | false | false | false | false | let point_eval h p =
| let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose4x4_uint32 | val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t | val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t | let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'') | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 31,
"start_col": 0,
"start_line": 29
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | vs: Lib.IntVector.Transpose.vec_t4 t -> Lib.IntVector.Transpose.vec_t4 t | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Prims.eq2",
"Lib.IntTypes.inttype",
"Lib.IntTypes.U32",
"Lib.IntVector.Transpose.vec_t4",
"Lib.IntVector.vec_t",
"FStar.Pervasives.Native.Mktuple4",
"Lib.IntVector.Transpose.transpose4x4_0"
] | [] | false | false | false | false | false | let transpose4x4_uint32 #t vs =
| let v0'', v2'', v1'', v3'' = transpose4x4_0 #t vs in
(v0'', v1'', v2'', v3'') | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_f | val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t | val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t | let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 41,
"start_col": 0,
"start_line": 40
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t * len) ->
i: Prims.nat{i < len}
-> Hacl.Spec.Bignum.Definitions.limb t | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.nat",
"Prims.op_LessThan",
"Lib.ByteSequence.uint_from_bytes_be",
"Lib.IntTypes.SEC",
"Lib.Sequence.sub",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | false | false | false | false | false | let bn_from_bytes_be_f #t len b i =
| uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t)) | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.point_inv_t | val point_inv_t (h: mem) (p: point) : GTot Type0 | val point_inv_t (h: mem) (p: point) : GTot Type0 | let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 31,
"end_line": 47,
"start_col": 0,
"start_line": 43
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Impl.Ed25519.Field51.point -> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.HyperStack.mem",
"Hacl.Impl.Ed25519.Field51.point",
"Prims.l_and",
"Hacl.Impl.Ed25519.Field51.mul_inv_t",
"Lib.Buffer.gsub",
"Lib.Buffer.MUT",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | false | true | let point_inv_t (h: mem) (p: point) : GTot Type0 =
| mul_inv_t h (gsub p 0ul 5ul) /\ mul_inv_t h (gsub p 5ul 5ul) /\ mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.f_lseq4 | val f_lseq4 (#t: v_inttype) (vs: lseq (vec_t t 4) 4) (f: (vec_t4 t -> vec_t4 t))
: lseq (vec_t t 4) 4 | val f_lseq4 (#t: v_inttype) (vs: lseq (vec_t t 4) 4) (f: (vec_t4 t -> vec_t4 t))
: lseq (vec_t t 4) 4 | let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3 | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 178,
"start_col": 0,
"start_line": 175
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
/// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 |
vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4 ->
f: (_: Lib.IntVector.Transpose.vec_t4 t -> Lib.IntVector.Transpose.vec_t4 t)
-> Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.IntVector.Transpose.vec_t4",
"Lib.Sequence.create4",
"FStar.Pervasives.Native.Mktuple4",
"FStar.Pervasives.Native.tuple4",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let f_lseq4 (#t: v_inttype) (vs: lseq (vec_t t 4) 4) (f: (vec_t4 t -> vec_t4 t))
: lseq (vec_t t 4) 4 =
| let v0, v1, v2, v3 = (vs.[ 0 ], vs.[ 1 ], vs.[ 2 ], vs.[ 3 ]) in
let r0, r1, r2, r3 = f (v0, v1, v2, v3) in
create4 r0 r1 r2 r3 | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_ | val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len | val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len | let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 51,
"start_col": 0,
"start_line": 50
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t * len)
-> Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.Sequence.createi",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_f",
"Hacl.Spec.Bignum.Definitions.lbignum"
] | [] | false | false | false | false | false | let bn_from_bytes_be_ #t len b =
| createi len (bn_from_bytes_be_f len b) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transposewxw_f_l | val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w | val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w | let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l] | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 158,
"start_col": 0,
"start_line": 151
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 |
n: Prims.nat{Prims.pow2 n == w} ->
i: Prims.nat{i < n} ->
vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t w) w ->
l: Prims.nat{l < w}
-> Lib.IntVector.vec_t t w | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.width",
"Lib.IntVector.v_inttype",
"Prims.nat",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Prims.pow2",
"Prims.op_LessThan",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Lib.IntVector.vec_interleave_low_n",
"Lib.Sequence.op_String_Access",
"Prims.op_Addition",
"Prims.unit",
"Lib.IntVector.Transpose.lemma_l_plus_pow2i_lt",
"Prims.bool",
"Lib.IntVector.vec_interleave_high_n",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_1"
] | [] | false | false | false | false | false | let transposewxw_f_l #w #t n i vs l =
| Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then
(lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[ l ] vs.[ l + pow2 i ])
else vec_interleave_high_n (pow2 i) vs.[ l - pow2 i ] vs.[ l ] | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.lemma_l_plus_pow2i_lt | val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w) | val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w) | let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
} | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 138,
"start_col": 0,
"start_line": 119
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | n: Prims.nat{Prims.pow2 n == w} -> i: Prims.nat{i < n} -> l: Prims.nat{l < w}
-> FStar.Pervasives.Lemma (requires l % (2 * Prims.pow2 i) < Prims.pow2 i)
(ensures l + Prims.pow2 i < w) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.eq2",
"Prims.pow2",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.op_LessThanOrEqual",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Prims.op_Division",
"Prims.op_Modulus",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.squash",
"FStar.Math.Lemmas.pow2_plus",
"Prims._assert",
"FStar.Math.Lemmas.pow2_double_sum",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.lemma_div_lt_nat"
] | [] | false | false | true | false | false | let lemma_l_plus_pow2i_lt #w n i l =
| let pow2i1 = pow2 (i + 1) in
calc ( < ) {
l + pow2 i;
( == ) { Math.Lemmas.euclidean_division_definition l pow2i1 }
(l / pow2i1) * pow2i1 + l % pow2i1 + pow2 i;
( == ) { Math.Lemmas.pow2_plus 1 i }
(l / pow2i1) * pow2i1 + l % (2 * pow2 i) + pow2 i;
( < ) { assert (l % (2 * pow2 i) < pow2 i) }
(l / pow2i1) * pow2i1 + pow2 i + pow2 i;
( == ) { Math.Lemmas.pow2_double_sum i }
(l / pow2i1) * pow2i1 + pow2i1;
( == ) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
( <= ) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
( == ) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
} | false |
Hacl.Impl.Curve25519.Fields.Core.fsti | Hacl.Impl.Curve25519.Fields.Core.fmul1_t | val fmul1_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2)) | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 290,
"start_col": 0,
"start_line": 278
} | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17 | {
"checked_file": "/",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"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": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem",
"Lib.IntTypes.uint64",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fmul1_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.state_inv_t",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC"
] | [] | false | false | false | true | true | let fmul1_t (s: field_spec) (p: Type0) =
| out: felem s -> f1: felem s -> f2: uint64
-> Stack unit
(requires
fun h -> p /\ live h out /\ live h f1 /\ (disjoint out f1 \/ out == f1) /\ fmul1_pre h f1 f2
)
(ensures
fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2)) | false |
|
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be | val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 65,
"start_col": 0,
"start_line": 60
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t)) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Prims.int",
"Prims.pos",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.lbignum"
] | [] | false | false | false | false | false | let bn_from_bytes_be #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp | false |
Steel.ST.GhostPCMReference.fst | Steel.ST.GhostPCMReference.read | val read (#o:inames)
(#a:Type)
(#pcm:pcm a)
(#v0:a)
(r:ref a pcm)
: STGhost a o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires True)
(ensures fun v -> compatible pcm v0 v) | val read (#o:inames)
(#a:Type)
(#pcm:pcm a)
(#v0:a)
(r:ref a pcm)
: STGhost a o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires True)
(ensures fun v -> compatible pcm v0 v) | let read (#o:inames)
(#a:Type)
(#pcm:pcm a)
(#v0:a)
(r:ref a pcm)
: STGhost a o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires True)
(ensures fun v -> compatible pcm v0 v)
= let v = coerce_ghost (fun _ -> G.read r) in
downgrade_val v | {
"file_name": "lib/steel/Steel.ST.GhostPCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 19,
"end_line": 56,
"start_col": 0,
"start_line": 45
} | (*
Copyright 2021 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.ST.GhostPCMReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
open FStar.PCM
open FStar.Universe
module UP = FStar.Universe.PCM
module G = Steel.GhostPCMReference
let ref (a:Type u#0) (p:pcm a) : Type u#0 =
G.ref (raise_t u#0 u#1 a) (UP.raise p)
/// pts_to is fixed to ref contents in u#0
let pts_to (#a:Type u#0) (#pcm:pcm a) (r:ref a pcm) ([@@@smt_fallback] v:a)
= G.pts_to #(raise_t a) #(UP.raise pcm) r (raise_val v)
/// Allocates a new reference, initially storing value [x].
let alloc (#o:inames)
(#a:Type)
(#pcm:pcm a)
(x:a)
: STGhost (ref a pcm) o
emp
(fun r -> pts_to r x)
(requires pcm.refine x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> G.alloc (raise_val x)) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostPCMReference.fsti.checked",
"prims.fst.checked",
"FStar.Universe.PCM.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostPCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.GhostPCMReference",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Universe.PCM",
"short_module": "UP"
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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.ST.GhostPCMReference.ref a pcm -> Steel.ST.Effect.Ghost.STGhost a | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"FStar.PCM.pcm",
"Steel.ST.GhostPCMReference.ref",
"FStar.Universe.downgrade_val",
"FStar.Universe.raise_t",
"Steel.ST.Coercions.coerce_ghost",
"Steel.GhostPCMReference.pts_to",
"FStar.Universe.PCM.raise",
"FStar.Universe.raise_val",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"FStar.PCM.compatible",
"Prims.unit",
"Steel.GhostPCMReference.read",
"Steel.ST.GhostPCMReference.pts_to"
] | [] | false | true | false | false | false | let read (#o: inames) (#a: Type) (#pcm: pcm a) (#v0: a) (r: ref a pcm)
: STGhost a
o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires True)
(ensures fun v -> compatible pcm v0 v) =
| let v = coerce_ghost (fun _ -> G.read r) in
downgrade_val v | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_uint_lemma | val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x) | val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x) | let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 24,
"end_line": 30,
"start_col": 0,
"start_line": 22
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_pos -> x: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Convert.bn_from_uint len x) ==
Lib.IntTypes.uint_v x) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval1",
"Lib.Sequence.slice",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.bn_eval_zeroes",
"Prims.op_Subtraction",
"Lib.Sequence.eq_intro",
"Lib.Sequence.create",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int"
] | [] | true | false | true | false | false | let bn_from_uint_lemma #t len x =
| let b = create len (uint #t 0) in
let b = b.[ 0 ] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1) | false |
Steel.LockCoupling.fsti | Steel.LockCoupling.list_inv | val list_inv (#a: Type) (p: ref (llist_cell a)) (repr: list a) : Tot vprop (decreases repr) | val list_inv (#a: Type) (p: ref (llist_cell a)) (repr: list a) : Tot vprop (decreases repr) | let rec list_inv (#a:Type) (p:ref (llist_cell a)) (repr:list a)
: Tot vprop (decreases repr)
= match repr with
| [] -> pure (p == null)
| hd::tl ->
h_exists (fun cell ->
pts_to p half cell `star`
pure (cell.v == hd) `star`
list_inv cell.next tl) | {
"file_name": "lib/steel/Steel.LockCoupling.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 30,
"end_line": 70,
"start_col": 0,
"start_line": 62
} | (*
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.LockCoupling
open Steel.ST.Util
open Steel.ST.Reference
open Steel.FractionalPermission
(*
This example sketches how an invariant for lock-coupling list
(a list that stores a lock at each cell protecting its tail pointer)
might work.
It relies on strictly positive version of the exists and pts_to
separation logic predicates, although the libraries are not
currently annotated with such positivity annotations.=
*)
(* It is relatively easy to show that h_exists is strictly positive *)
val h_exists (#[@@@strictly_positive] a:Type)
([@@@strictly_positive] p:(a -> vprop))
: vprop
(* the pts_to predicate is a bit more subtle. It is an instance
of a more general form that involves assertions about a PCM,
and it is possible to construct PCMs that are not strictly
positive. However, the basic pts_to predicate that this refers to,
for the fractional permission PCM, is strictly positive.
Revising the library to enable decorating pts_to predicates derived
from positive PCMs remains to be done. *)
val pts_to (#[@@@strictly_positive] a:Type)
(r:ref a)
(f:perm)
(v:a) : vprop
val lock ([@@@strictly_positive] p:vprop) : Type0
let half = half_perm full_perm
(* The lock at each cell holds half permission to the next pointer *)
noeq
type llist_cell (a:Type0) : Type = {
v : a;
next : ref (llist_cell a);
lock : lock (h_exists (pts_to next half))
} | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Reference.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.LockCoupling.fsti"
} | [
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"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 | p: Steel.ST.Reference.ref (Steel.LockCoupling.llist_cell a) -> repr: Prims.list a
-> Prims.Tot Steel.Effect.Common.vprop | Prims.Tot | [
"total",
""
] | [] | [
"Steel.ST.Reference.ref",
"Steel.LockCoupling.llist_cell",
"Prims.list",
"Steel.ST.Util.pure",
"Prims.eq2",
"Steel.ST.Reference.null",
"Steel.LockCoupling.h_exists",
"Steel.Effect.Common.star",
"Steel.LockCoupling.pts_to",
"Steel.LockCoupling.half",
"Steel.LockCoupling.__proj__Mkllist_cell__item__v",
"Steel.LockCoupling.list_inv",
"Steel.LockCoupling.__proj__Mkllist_cell__item__next",
"Steel.Effect.Common.vprop"
] | [
"recursion"
] | false | false | false | true | false | let rec list_inv (#a: Type) (p: ref (llist_cell a)) (repr: list a) : Tot vprop (decreases repr) =
| match repr with
| [] -> pure (p == null)
| hd :: tl ->
h_exists (fun cell ->
((pts_to p half cell) `star` (pure (cell.v == hd))) `star` (list_inv cell.next tl)) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.f_lseq8 | val f_lseq8 (#t: v_inttype) (vs: lseq (vec_t t 8) 8) (f: (vec_t8 t -> vec_t8 t))
: lseq (vec_t t 8) 8 | val f_lseq8 (#t: v_inttype) (vs: lseq (vec_t t 8) 8) (f: (vec_t8 t -> vec_t8 t))
: lseq (vec_t t 8) 8 | let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7 | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 33,
"end_line": 195,
"start_col": 0,
"start_line": 192
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 |
vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8 ->
f: (_: Lib.IntVector.Transpose.vec_t8 t -> Lib.IntVector.Transpose.vec_t8 t)
-> Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8 | Prims.Tot | [
"total"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.IntVector.Transpose.vec_t8",
"Lib.Sequence.create8",
"FStar.Pervasives.Native.Mktuple8",
"FStar.Pervasives.Native.tuple8",
"Lib.Sequence.op_String_Access"
] | [] | false | false | false | false | false | let f_lseq8 (#t: v_inttype) (vs: lseq (vec_t t 8) 8) (f: (vec_t8 t -> vec_t8 t))
: lseq (vec_t t 8) 8 =
| let v0, v1, v2, v3, v4, v5, v6, v7 =
(vs.[ 0 ], vs.[ 1 ], vs.[ 2 ], vs.[ 3 ], vs.[ 4 ], vs.[ 5 ], vs.[ 6 ], vs.[ 7 ])
in
let r0, r1, r2, r3, r4, r5, r6, r7 = f (v0, v1, v2, v3, v4, v5, v6, v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7 | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.reverse | val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len | val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len | let reverse #t #len b = createi len (fun i -> b.[len - i - 1]) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 137,
"start_col": 0,
"start_line": 137
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
/// | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | b: Hacl.Spec.Bignum.Definitions.lbignum t len -> Hacl.Spec.Bignum.Definitions.lbignum t len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.createi",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.op_String_Access",
"Prims.op_Subtraction"
] | [] | false | false | false | false | false | let reverse #t #len b =
| createi len (fun i -> b.[ len - i - 1 ]) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be_f | val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t) | val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t) | let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1] | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 91,
"start_col": 0,
"start_line": 90
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Prims.nat{i < len} ->
_: Prims.unit
-> Prims.unit * Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.unit",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.IntTypes.numbytes",
"Lib.ByteSequence.uint_to_bytes_be",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let bn_to_bytes_be_f #t len b i () =
| (), uint_to_bytes_be b.[ len - i - 1 ] | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.inv_ext_point | val inv_ext_point (a: LSeq.lseq uint64 20) : Type0 | val inv_ext_point (a: LSeq.lseq uint64 20) : Type0 | let inv_ext_point (a:LSeq.lseq uint64 20) : Type0 =
Spec.Ed25519.point_inv (refl_ext_point a) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 66,
"start_col": 0,
"start_line": 65
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul)
unfold
let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4])
unfold
let refl_ext_point (a:LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point =
let open Hacl.Spec.Curve25519.Field51.Definition in
let x = feval (lseq_as_felem (LSeq.sub a 0 5)) in
let y = feval (lseq_as_felem (LSeq.sub a 5 5)) in
let z = feval (lseq_as_felem (LSeq.sub a 10 5)) in
let t = feval (lseq_as_felem (LSeq.sub a 15 5)) in
(x, y, z, t) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 20 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Spec.Ed25519.PointOps.point_inv",
"Hacl.Impl.Ed25519.Field51.refl_ext_point"
] | [] | false | false | false | false | true | let inv_ext_point (a: LSeq.lseq uint64 20) : Type0 =
| Spec.Ed25519.point_inv (refl_ext_point a) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose4x4_lemma_uint64_ij | val transpose4x4_lemma_uint64_ij: vs:lseq (vec_t U64 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U64 vs).[i]).[j] == (vec_v vs.[j]).[i]) | val transpose4x4_lemma_uint64_ij: vs:lseq (vec_t U64 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U64 vs).[i]).[j] == (vec_v vs.[j]).[i]) | let transpose4x4_lemma_uint64_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint64_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint64_4 vs0.[2] vs0.[3] | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 264,
"start_col": 0,
"start_line": 245
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0)
inline_for_extraction
let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7
val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012)
let transpose8x8_lseq_is_transposewxw #t vs0 =
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012)
val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose4x4_lemma_uint32_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_4 vs0.[2] vs0.[3]
val transpose4x4_lemma_uint64_ij: vs:lseq (vec_t U64 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U64 vs).[i]).[j] == (vec_v vs.[j]).[i]) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 |
vs: Lib.Sequence.lseq (Lib.IntVector.vec_t Lib.IntTypes.U64 4) 4 ->
i: Prims.nat{i < 4} ->
j: Prims.nat{j < 4}
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntVector.vec_v (Lib.IntVector.Transpose.transpose4x4_lseq vs).[ i ]).[ j ] ==
(Lib.IntVector.vec_v vs.[ j ]).[ i ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.IntTypes.U64",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntVector.vec_interleave_high_lemma_uint64_4",
"Lib.Sequence.op_String_Access",
"Prims.unit",
"Lib.IntVector.vec_interleave_low_lemma_uint64_4",
"Lib.IntVector.vec_interleave_high_n_lemma_uint64_4_2",
"Lib.IntVector.vec_interleave_low_n_lemma_uint64_4_2",
"Lib.IntVector.Transpose.transposewxw_f",
"Lib.LoopCombinators.eq_repeati0",
"Lib.LoopCombinators.unfold_repeati",
"Lib.IntVector.Transpose.transposewxw_lseq",
"Prims.int",
"Lib.IntVector.Transpose.transpose4x4_lseq_is_transposewxw"
] | [] | true | false | true | false | false | let transpose4x4_lemma_uint64_ij vs0 i j =
| transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint64_4_2 res0.[ 0 ] res0.[ 2 ];
vec_interleave_high_n_lemma_uint64_4_2 res0.[ 0 ] res0.[ 2 ];
vec_interleave_low_n_lemma_uint64_4_2 res0.[ 1 ] res0.[ 3 ];
vec_interleave_high_n_lemma_uint64_4_2 res0.[ 1 ] res0.[ 3 ];
vec_interleave_low_lemma_uint64_4 vs0.[ 0 ] vs0.[ 1 ];
vec_interleave_high_lemma_uint64_4 vs0.[ 0 ] vs0.[ 1 ];
vec_interleave_low_lemma_uint64_4 vs0.[ 2 ] vs0.[ 3 ];
vec_interleave_high_lemma_uint64_4 vs0.[ 2 ] vs0.[ 3 ] | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.twice_reverse | val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b) | val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b) | let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 34,
"end_line": 145,
"start_col": 0,
"start_line": 141
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1]) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures Hacl.Spec.Bignum.Convert.reverse (Hacl.Spec.Bignum.Convert.reverse b) == b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Convert.reverse",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Prims.l_True",
"Prims.squash",
"Lib.Sequence.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let twice_reverse #t #len b =
| let lemma_aux (i: nat{i < len}) : Lemma ((reverse (reverse b)).[ i ] == b.[ i ]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b | false |
Steel.ST.Array.fst | Steel.ST.Array.upd | val upd
(#t: Type)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t {US.v i < Seq.length s})
(v: t)
: STT unit
(pts_to a P.full_perm s)
(fun res -> pts_to a P.full_perm (Seq.upd s (US.v i) v)) | val upd
(#t: Type)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t {US.v i < Seq.length s})
(v: t)
: STT unit
(pts_to a P.full_perm s)
(fun res -> pts_to a P.full_perm (Seq.upd s (US.v i) v)) | let upd #_ a #s i v =
rewrite
(pts_to a _ _)
(H.pts_to a P.full_perm (seq_map raise s));
H.upd a i (raise v);
assert (seq_map raise (Seq.upd s (US.v i) v) `Seq.equal` Seq.upd (seq_map raise s) (US.v i) (raise v));
rewrite
(H.pts_to _ _ _)
(pts_to _ _ _) | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 18,
"end_line": 185,
"start_col": 0,
"start_line": 177
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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.ST.Array
module US = FStar.SizeT
/// Lifting a value of universe 0 to universe 1. We use
/// FStar.Universe, since FStar.Extraction.Krml is set to extract
/// those functions to identity.
inline_for_extraction
[@@ noextract_to "krml"]
let raise_t (t: Type0) : Type u#1 = FStar.Universe.raise_t t
inline_for_extraction
[@@noextract_to "krml"]
let raise (#t: Type) (x: t) : Tot (raise_t t) =
FStar.Universe.raise_val x
inline_for_extraction
[@@noextract_to "krml"]
let lower (#t: Type) (x: raise_t t) : Tot t =
FStar.Universe.downgrade_val x
/// A map operation on sequences. Here we only need Ghost versions,
/// because such sequences are only used in vprops or with their
/// selectors.
let rec seq_map
(#t: Type u#a)
(#t' : Type u#b)
(f: (t -> GTot t'))
(s: Seq.seq t)
: Ghost (Seq.seq t')
(requires True)
(ensures (fun s' ->
Seq.length s' == Seq.length s /\
(forall i . {:pattern (Seq.index s' i)} Seq.index s' i == f (Seq.index s i))
))
(decreases (Seq.length s))
= if Seq.length s = 0
then Seq.empty
else Seq.cons (f (Seq.index s 0)) (seq_map f (Seq.slice s 1 (Seq.length s)))
let seq_map_append
(#t: Type u#a)
(#t': Type u#b)
(f: (t -> GTot t'))
(s1 s2: Seq.seq t)
: Lemma
(seq_map f (s1 `Seq.append` s2) `Seq.equal` (seq_map f s1 `Seq.append` seq_map f s2))
= ()
let seq_map_raise_inj
(#elt: Type0)
(s1 s2: Seq.seq elt)
: Lemma
(requires (seq_map raise s1 == seq_map raise s2))
(ensures (s1 == s2))
[SMTPat (seq_map raise s1); SMTPat (seq_map raise s2)]
= assert (seq_map lower (seq_map raise s1) `Seq.equal` s1);
assert (seq_map lower (seq_map raise s2) `Seq.equal` s2)
/// Implementation of the interface
/// base, ptr, array, pts_to
module H = Steel.ST.HigherArray
let base_t elt = H.base_t (raise_t elt)
let base_len b = H.base_len b
let ptr elt = H.ptr (raise_t elt)
let null_ptr elt = H.null_ptr (raise_t elt)
let is_null_ptr p = H.is_null_ptr p
let base p = H.base p
let offset p = H.offset p
let ptr_base_offset_inj p1 p2 = H.ptr_base_offset_inj p1 p2
let base_len_null_ptr elt = H.base_len_null_ptr (raise_t elt)
let length_fits a = H.length_fits a
let pts_to a p s = H.pts_to a p (seq_map raise s)
let pts_to_length a s =
H.pts_to_length a _
let h_array_eq'
(#t: Type u#1)
(a1 a2: H.array t)
: Lemma
(requires (
dfst a1 == dfst a2 /\
(Ghost.reveal (dsnd a1) <: nat) == Ghost.reveal (dsnd a2)
))
(ensures (
a1 == a2
))
= ()
let pts_to_not_null #_ #t #p a s =
let _ = H.pts_to_not_null #_ #_ #p a (seq_map raise s) in
assert (a =!= H.null #(raise_t t));
Classical.move_requires (h_array_eq' a) (H.null #(raise_t t));
noop ()
let pts_to_inj a p1 s1 p2 s2 =
H.pts_to_inj a p1 (seq_map raise s1) p2 (seq_map raise s2)
/// Non-selector operations.
let malloc x n =
let res = H.malloc (raise x) n in
assert (seq_map raise (Seq.create (US.v n) x) `Seq.equal` Seq.create (US.v n) (raise x));
rewrite
(H.pts_to res _ _)
(pts_to res _ _);
return res
let free #_ x =
let s = elim_exists () in
rewrite
(pts_to x _ _)
(H.pts_to x P.full_perm (seq_map raise s));
H.free x
let share
#_ #_ #x a p p1 p2
= rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite
(H.pts_to a p1 _)
(pts_to a p1 x);
rewrite
(H.pts_to a p2 _)
(pts_to a p2 x)
let gather
#_ #_ a #x1 p1 #x2 p2
= rewrite
(pts_to a p1 _)
(H.pts_to a p1 (seq_map raise x1));
rewrite
(pts_to a p2 _)
(H.pts_to a p2 (seq_map raise x2));
H.gather a p1 p2;
rewrite
(H.pts_to a _ _)
(pts_to _ _ _)
let index #_ #p a #s i =
rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise s));
let res = H.index a i in
rewrite
(H.pts_to _ _ _)
(pts_to _ _ _);
return (lower res) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.Array.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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 |
a: Steel.ST.Array.array t ->
i: FStar.SizeT.t{FStar.SizeT.v i < FStar.Seq.Base.length (FStar.Ghost.reveal s)} ->
v: t
-> Steel.ST.Effect.STT Prims.unit | Steel.ST.Effect.STT | [] | [] | [
"Steel.ST.Array.array",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.SizeT.t",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.SizeT.v",
"FStar.Seq.Base.length",
"FStar.Ghost.reveal",
"Steel.ST.Util.rewrite",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.ST.HigherArray.pts_to",
"Steel.ST.Array.raise_t",
"Steel.FractionalPermission.full_perm",
"FStar.Seq.Base.upd",
"Steel.ST.Array.seq_map",
"Steel.ST.Array.raise",
"Steel.ST.Array.pts_to",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Steel.ST.HigherArray.upd"
] | [] | false | true | false | false | false | let upd #_ a #s i v =
| rewrite (pts_to a _ _) (H.pts_to a P.full_perm (seq_map raise s));
H.upd a i (raise v);
assert ((seq_map raise (Seq.upd s (US.v i) v))
`Seq.equal`
(Seq.upd (seq_map raise s) (US.v i) (raise v)));
rewrite (H.pts_to _ _ _) (pts_to _ _ _) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_le | val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 79,
"start_col": 0,
"start_line": 74
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t)) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.ByteSequence.uints_from_bytes_le",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Prims.int",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Definitions.lbignum"
] | [] | false | false | false | false | false | let bn_from_bytes_le #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose4x4_lseq_is_transposewxw | val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0) | val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0) | let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0) | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 188,
"start_col": 0,
"start_line": 183
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Lib.IntVector.Transpose.transposewxw_lseq 2 vs)
(Lib.IntVector.Transpose.f_lseq4 vs Lib.IntVector.Transpose.transpose4x4_0)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.Sequence.eq_intro",
"Lib.IntVector.Transpose.transposewxw_lseq",
"Lib.IntVector.Transpose.f_lseq4",
"Lib.IntVector.Transpose.transpose4x4_0",
"Prims.unit",
"Lib.LoopCombinators.eq_repeati0",
"Lib.IntVector.Transpose.transposewxw_f",
"Lib.LoopCombinators.unfold_repeati",
"Prims.int"
] | [] | true | false | true | false | false | let transpose4x4_lseq_is_transposewxw #t vs0 =
| let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose4x4_lemma | val transpose4x4_lemma: #t:v_inttype{t = U32 \/ t = U64} -> vs:lseq (vec_t t 4) 4 ->
Lemma (forall (i:nat{i < 4}) (j:nat{j < 4}). (vec_v (transpose4x4_lseq vs).[i]).[j] == (vec_v vs.[j]).[i]) | val transpose4x4_lemma: #t:v_inttype{t = U32 \/ t = U64} -> vs:lseq (vec_t t 4) 4 ->
Lemma (forall (i:nat{i < 4}) (j:nat{j < 4}). (vec_v (transpose4x4_lseq vs).[i]).[j] == (vec_v vs.[j]).[i]) | let transpose4x4_lemma #t vs =
match t with
| U32 -> Classical.forall_intro_2 (transpose4x4_lemma_uint32_ij vs)
| U64 -> Classical.forall_intro_2 (transpose4x4_lemma_uint64_ij vs) | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 313,
"start_col": 0,
"start_line": 310
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0)
inline_for_extraction
let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7
val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012)
let transpose8x8_lseq_is_transposewxw #t vs0 =
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012)
val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose4x4_lemma_uint32_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_4 vs0.[2] vs0.[3]
val transpose4x4_lemma_uint64_ij: vs:lseq (vec_t U64 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U64 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose4x4_lemma_uint64_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint64_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint64_4 vs0.[2] vs0.[3]
val transpose8x8_lemma_uint32_ij: vs:lseq (vec_t U32 8) 8 -> i:nat{i < 8} -> j:nat{j < 8} ->
Lemma ((vec_v (transpose8x8_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose8x8_lemma_uint32_ij vs0 i j =
transpose8x8_lseq_is_transposewxw vs0;
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
let res1 = transposewxw_f n 1 res0 in
let res2 = transposewxw_f n 2 res1 in
vec_interleave_low_n_lemma_uint32_8_4 res1.[0] res1.[4];
vec_interleave_low_n_lemma_uint32_8_4 res1.[1] res1.[5];
vec_interleave_low_n_lemma_uint32_8_4 res1.[2] res1.[6];
vec_interleave_low_n_lemma_uint32_8_4 res1.[3] res1.[7];
vec_interleave_high_n_lemma_uint32_8_4 res1.[0] res1.[4];
vec_interleave_high_n_lemma_uint32_8_4 res1.[1] res1.[5];
vec_interleave_high_n_lemma_uint32_8_4 res1.[2] res1.[6];
vec_interleave_high_n_lemma_uint32_8_4 res1.[3] res1.[7];
vec_interleave_low_n_lemma_uint32_8_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_8_2 res0.[1] res0.[3];
vec_interleave_low_n_lemma_uint32_8_2 res0.[4] res0.[6];
vec_interleave_low_n_lemma_uint32_8_2 res0.[5] res0.[7];
vec_interleave_high_n_lemma_uint32_8_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_8_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_8_2 res0.[4] res0.[6];
vec_interleave_high_n_lemma_uint32_8_2 res0.[5] res0.[7];
vec_interleave_low_lemma_uint32_8 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_8 vs0.[2] vs0.[3];
vec_interleave_low_lemma_uint32_8 vs0.[4] vs0.[5];
vec_interleave_low_lemma_uint32_8 vs0.[6] vs0.[7];
vec_interleave_high_lemma_uint32_8 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_8 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_8 vs0.[4] vs0.[5];
vec_interleave_high_lemma_uint32_8 vs0.[6] vs0.[7] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4
-> FStar.Pervasives.Lemma
(ensures
forall (i: Prims.nat{i < 4}) (j: Prims.nat{j < 4}).
(Lib.IntVector.vec_v (Lib.IntVector.Transpose.transpose4x4_lseq vs).[ i ]).[ j ] ==
(Lib.IntVector.vec_v vs.[ j ]).[ i ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Equality",
"Lib.IntTypes.inttype",
"Lib.IntTypes.U32",
"Lib.IntTypes.U64",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"FStar.Classical.forall_intro_2",
"Prims.nat",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntVector.vec_v",
"Lib.Sequence.op_String_Access",
"Lib.IntVector.Transpose.transpose4x4_lseq",
"Lib.IntVector.Transpose.transpose4x4_lemma_uint32_ij",
"Lib.IntVector.Transpose.transpose4x4_lemma_uint64_ij",
"Prims.unit"
] | [] | false | false | true | false | false | let transpose4x4_lemma #t vs =
| match t with
| U32 -> Classical.forall_intro_2 (transpose4x4_lemma_uint32_ij vs)
| U64 -> Classical.forall_intro_2 (transpose4x4_lemma_uint64_ij vs) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be | val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 28,
"end_line": 117,
"start_col": 0,
"start_line": 113
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t))
-> Lib.Sequence.lseq Lib.IntTypes.uint8 len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.sub",
"Lib.IntTypes.uint8",
"Prims.op_Subtraction",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_",
"Prims.int",
"Prims.pos",
"Prims.pow2"
] | [] | false | false | false | false | false | let bn_to_bytes_be #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len | false |
SelectorsLList3Example.fst | SelectorsLList3Example.is_null | val is_null (ptr: t) : (b: bool{b <==> ptr == null_llist ()}) | val is_null (ptr: t) : (b: bool{b <==> ptr == null_llist ()}) | let is_null (ptr:t) : (b:bool{b <==> ptr == null_llist ()})
= LL.is_null ptr | {
"file_name": "share/steel/examples/steel/llist3/SelectorsLList3Example.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 34,
"start_col": 0,
"start_line": 33
} | module SelectorsLList3Example
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.ArrayRef
module L = FStar.List.Tot
module LL = Selectors.LList3
module U32 = FStar.UInt32
module MB = LowStar.Monotonic.Buffer // for is_null
inline_for_extraction noextract let a = U32.t
let cell = LL.cell a
/// The type of a list: A reference to a cell
let t = LL.t a
let next (c:cell) : t = LL.next c
let data (c:cell) : a = LL.data c
let mk_cell (n: t) (d:a)
: Pure cell
(requires True)
(ensures fun c ->
next c == n /\
data c == d)
= LL.mk_cell n d
/// The null list pointer
let null_llist () : t = LL.null_llist | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"Steel.ArrayRef.fsti.checked",
"Selectors.LList3.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "SelectorsLList3Example.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer // for is_null",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Selectors.LList3",
"short_module": "LL"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.ArrayRef",
"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.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 | ptr: SelectorsLList3Example.t -> b: Prims.bool{b <==> ptr == SelectorsLList3Example.null_llist ()} | Prims.Tot | [
"total"
] | [] | [
"SelectorsLList3Example.t",
"Selectors.LList3.is_null",
"SelectorsLList3Example.a",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2",
"SelectorsLList3Example.null_llist"
] | [] | false | false | false | false | false | let is_null (ptr: t) : (b: bool{b <==> ptr == null_llist ()}) =
| LL.is_null ptr | false |
Hacl.Spec.K256.Field52.Definitions.Lemmas.fst | Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_a_plus_b_mul_pow256 | val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | let lemma_a_plus_b_mul_pow256 a b =
calc (==) {
(a + b * pow2 256) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
(==) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
} | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 373,
"start_col": 0,
"start_line": 362
} | module Hacl.Spec.K256.Field52.Definitions.Lemmas
open FStar.Mul
open Lib.IntTypes
open Hacl.Spec.K256.Field52.Definitions
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.K256
module ML = Hacl.Spec.K256.MathLemmas
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
val lemma_as_nat_mod2: x:felem5 ->
Lemma (let (x0,x1,x2,x3,x4) = x in as_nat5 x % 2 = v x0 % 2)
let lemma_as_nat_mod2 x =
let (x0,x1,x2,x3,x4) = x in
assert (as_nat5 x = v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208);
assert (as_nat5 x % 2 = (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208) % 2);
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156) (v x4) 208;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104) (v x3) 156;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52) (v x2) 104;
ML.lemma_a_plus_b_pow2_mod2 (v x0) (v x1) 52;
assert (as_nat5 x % 2 = v x0 % 2)
val lemma_nat_from_bytes_be_mod2: f:LSeq.lseq uint8 32 ->
Lemma (BSeq.nat_from_bytes_be f % 2 = v (LSeq.index f 31) % 2)
let lemma_nat_from_bytes_be_mod2 f =
let x0 = LSeq.index f 31 in
BSeq.nat_from_intseq_be_slice_lemma f 31;
BSeq.nat_from_intseq_be_lemma0 (LSeq.slice f 31 32);
assert (BSeq.nat_from_intseq_be f == v x0 + pow2 8 * BSeq.nat_from_intseq_be (LSeq.slice f 0 31));
ML.lemma_a_plus_b_pow2_mod2 (v x0) (BSeq.nat_from_intseq_be (LSeq.slice f 0 31)) 8
val unfold_nat_from_uint64_four: b:LSeq.lseq uint64 4 ->
Lemma (BSeq.nat_from_intseq_be b ==
v (LSeq.index b 3) + v (LSeq.index b 2) * pow2 64 +
v (LSeq.index b 1) * pow2 128 + v (LSeq.index b 0) * pow2 192)
let unfold_nat_from_uint64_four b =
let b0 = v (LSeq.index b 0) in
let b1 = v (LSeq.index b 1) in
let b2 = v (LSeq.index b 2) in
let b3 = v (LSeq.index b 3) in
let res = BSeq.nat_from_intseq_be b in
BSeq.nat_from_intseq_be_slice_lemma b 3;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 3 4);
assert (res == b3 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 3)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #3 (Seq.slice b 0 3) 2;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 2 3);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 3) == b2 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 2)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #2 (Seq.slice b 0 2) 1;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 1 2);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 2) == b1 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 1)));
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 0 1);
assert (res == b3 + pow2 64 * (b2 + pow2 64 * (b1 + pow2 64 * b0)));
ML.lemma_as_nat64_horner b3 b2 b1 b0
val lemma_prime : unit -> Lemma (pow2 256 % S.prime = 0x1000003D1)
let lemma_prime () = ()
val lemma_pow2_256_minus_prime : unit -> Lemma (pow2 256 - S.prime = 0x1000003D1)
let lemma_pow2_256_minus_prime () = ()
val lemma_pow2_260_mod_prime: unit -> Lemma (pow2 260 % S.prime = 0x1000003D10)
let lemma_pow2_260_mod_prime () =
calc (==) {
pow2 260 % S.prime;
(==) { Math.Lemmas.pow2_plus 256 4 }
pow2 256 * pow2 4 % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (pow2 256) (pow2 4) S.prime }
(pow2 256 % S.prime) * pow2 4 % S.prime;
(==) { lemma_prime () }
0x1000003D1 * pow2 4 % S.prime;
(==) { assert_norm (0x1000003D1 * pow2 4 = 0x1000003D10) }
0x1000003D10 % S.prime;
(==) { Math.Lemmas.small_mod 0x1000003D10 S.prime }
0x1000003D10;
}
val lemma_as_nat_bound_f4_lt_powa: f:felem5 -> a:nat -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 a))
(ensures as_nat5 f <= pow2 (208 + a) - 1)
let lemma_as_nat_bound_f4_lt_powa f a =
let (f0,f1,f2,f3,f4) = f in
calc (<=) { //as_nat5 f ==
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) { }
pow2 52 - 1 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) {
Math.Lemmas.lemma_mult_le_right pow52 (v f1) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow52 }
pow2 52 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow104 (v f2) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow104;
Math.Lemmas.pow2_plus 52 52 }
pow2 52 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow156 (v f3) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow156;
Math.Lemmas.pow2_plus 52 104 }
pow2 52 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow208 (v f4) (pow2 a - 1);
Math.Lemmas.distributivity_sub_left (pow2 a) 1 pow208;
Math.Lemmas.pow2_plus 52 156;
Math.Lemmas.pow2_plus a 208 }
pow2 (208 + a) - 1;
}
val lemma_as_nat_bound: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat5 f < pow2 256)
let lemma_as_nat_bound f =
lemma_as_nat_bound_f4_lt_powa f 48
val lemma_as_nat_bound_f4_lt_pow12: f:felem5 -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 12))
(ensures as_nat5 f <= pow2 220 - 1)
let lemma_as_nat_bound_f4_lt_pow12 f =
lemma_as_nat_bound_f4_lt_powa f 12
val lemma_as_nat_decompose: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures (let (f0,f1,f2,f3,f4) = f in
v f4 = as_nat5 f / pow208 /\
v f3 = as_nat5 f % pow208 / pow156 /\
v f2 = as_nat5 f % pow156 / pow104 /\
v f1 = as_nat5 f % pow104 / pow52 /\
v f0 = as_nat5 f % pow52))
let lemma_as_nat_decompose f =
let (f0,f1,f2,f3,f4) = f in
lemma_as_nat_bound f;
Math.Lemmas.euclidean_division_definition (as_nat5 f) pow208;
assert (v f4 = as_nat5 f / pow208);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow208) pow156;
assert (v f3 = as_nat5 f % pow208 / pow156);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 156 208;
assert (as_nat5 f % pow208 % pow156 == as_nat5 f % pow156);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow156) pow104;
assert (v f2 = as_nat5 f % pow156 / pow104);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 104 156;
assert (as_nat5 f % pow156 % pow104 == as_nat5 f % pow104);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow104) pow52;
assert (v f1 = as_nat5 f % pow104 / pow52);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 52 104;
assert (as_nat5 f % pow104 % pow52 == as_nat5 f % pow52);
assert (v f0 = as_nat5 f % pow52)
#push-options "--ifuel 1"
val as_nat_inj (f1 f2: felem5) : Lemma
(requires
felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1) /\
as_nat5 f1 == as_nat5 f2)
(ensures
(let (a0,a1,a2,a3,a4) = f1 in let (b0,b1,b2,b3,b4) = f2 in
a0 == b0 /\ a1 == b1 /\ a2 == b2 /\ a3 == b3 /\ a4 == b4))
let as_nat_inj f1 f2 =
lemma_as_nat_decompose f1;
lemma_as_nat_decompose f2
#pop-options
val lemma_normalize_x_le_1: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 <= 1)
let lemma_normalize_x_le_1 t4 =
calc (==) {
(2 * (pow2 48 - 1)) / pow2 48;
(==) { Math.Lemmas.distributivity_add_right 2 (pow2 48) 1 }
(2 * pow2 48 - 2) / pow2 48;
(==) { Math.Lemmas.division_addition_lemma (-2) (pow2 48) 2 }
(-2) / pow2 48 + 2;
(==) { assert_norm ((-2) / pow2 48 = -1) }
1;
};
assert (v t4 <= 2 * (pow2 48 - 1));
Math.Lemmas.lemma_div_le (v t4) (2 * pow2 48 - 2) (pow2 48);
assert (v t4 / pow2 48 <= 1)
val lemma_div_pow48: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 == (if v t4 < pow2 48 then 0 else 1))
let lemma_div_pow48 t4 =
if v t4 < pow2 48 then
Math.Lemmas.small_div (v t4) (pow2 48)
else begin
lemma_normalize_x_le_1 t4;
assert (v t4 / pow2 48 <= 1);
Math.Lemmas.lemma_div_le (pow2 48) (v t4) (pow2 48);
assert (1 <= v t4 / pow2 48) end
val lemma_mask52: a:uint64 ->
Lemma (let r = a &. mask52 in
v r = v a % pow2 52 /\ felem_fits1 r 1)
let lemma_mask52 a =
let r = a &. mask52 in
assert_norm (v mask52 = pow2 52 - 1);
mod_mask_lemma a 52ul;
assert (v (mod_mask #U64 #SEC 52ul) == v mask52);
assert (v r = v a % pow2 52);
assert (felem_fits1 r 1)
val lemma_mask48: a:uint64 ->
Lemma (let r = a &. mask48 in
v r = v a % pow2 48 /\ felem_fits_last1 r 1)
let lemma_mask48 a =
let r = a &. mask48 in
assert_norm (v mask48 = pow2 48 - 1);
mod_mask_lemma a 48ul;
assert (v (mod_mask #U64 #SEC 48ul) == v mask48);
assert (v r = v a % pow2 48);
assert (felem_fits_last1 r 1)
val lemma_add_rsh52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52 m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max52 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 52 12 }
m1 * max52 + max52;
(==) { Math.Lemmas.distributivity_add_left m1 1 max52 }
(m1 + 1) * max52;
};
Math.Lemmas.lemma_mult_le_right max52 (m1 + 1) 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits1 c (m1 + 1))
val lemma_add_rsh52_last: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits_last1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52_last m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max48 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 48 12 }
m1 * max48 + max48;
(==) { Math.Lemmas.distributivity_add_left m1 1 max48 }
(m1 + 1) * max48;
};
Math.Lemmas.lemma_mult_le_right max48 (m1 + 1) 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits_last1 c (m1 + 1))
val lemma_carry52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52 m1 m2 a b
val lemma_carry_last52: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits_last1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry_last52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52_last m1 m2 a b
val lemma_small_sub_mod: a:nat -> n:pos -> Lemma
(requires n <= a /\ a < 2 * n)
(ensures a % n = a - n)
let lemma_small_sub_mod a n =
calc (==) {
a % n;
(==) { Math.Lemmas.sub_div_mod_1 a n }
(a - n) % n;
(==) { Math.Lemmas.small_mod (a - n) n }
a - n;
}
val carry_last_small_mod_lemma: t4:uint64 -> t3':uint64 -> Lemma
(requires felem_fits_last1 t4 1 /\
v (t4 +. (t3' >>. 52ul)) == v t4 + v t3' / pow2 52)
(ensures (let r = t4 +. (t3' >>. 52ul) in
felem_fits_last1 r 2 /\
v r < v t4 + pow2 12 /\ (v r >= pow2 48 ==> v r % pow2 48 < pow2 12)))
let carry_last_small_mod_lemma t4 t3' =
let r = t4 +. (t3' >>. 52ul) in
assert (v r = v t4 + v t3' / pow2 52);
Math.Lemmas.lemma_div_lt (v t3') 64 52;
assert (v r < v t4 + pow2 12);
Math.Lemmas.pow2_lt_compat 48 12;
assert (felem_fits_last1 r 2);
if v r >= pow2 48 then begin
lemma_small_sub_mod (v r) (pow2 48);
assert (v r % pow2 48 = v r - pow2 48);
assert (v r % pow2 48 < pow2 12) end
val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"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": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"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 | a: Prims.int -> b: Prims.int
-> FStar.Pervasives.Lemma
(ensures
(a + b * Prims.pow2 256) % Spec.K256.PointOps.prime ==
(a + b * 0x1000003D1) % Spec.K256.PointOps.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Spec.K256.PointOps.prime",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_prime"
] | [] | false | false | true | false | false | let lemma_a_plus_b_mul_pow256 a b =
| calc ( == ) {
(a + b * pow2 256) % S.prime;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
( == ) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
( == ) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
( == ) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
} | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_le | val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 130,
"start_col": 0,
"start_line": 126
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t))
-> Lib.Sequence.lseq Lib.IntTypes.uint8 len | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.op_Multiply",
"Lib.ByteSequence.uints_to_bytes_le",
"Prims.int",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.uint8"
] | [] | false | false | false | false | false | let bn_to_bytes_le #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be_ | val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len) | val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len) | let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 104,
"start_col": 0,
"start_line": 100
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t * len) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"Lib.Sequence.lseq",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Lib.Sequence.generate_blocks",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_f",
"Prims.nat",
"Prims.eqtype",
"Prims.unit"
] | [] | false | false | false | false | false | let bn_to_bytes_be_ #t len b =
| let a_spec (i: nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec (bn_to_bytes_be_f len b) () in
o | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose4x4_lemma_uint32_ij | val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i]) | val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i]) | let transpose4x4_lemma_uint32_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_4 vs0.[2] vs0.[3] | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 239,
"start_col": 0,
"start_line": 220
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0)
inline_for_extraction
let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7
val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012)
let transpose8x8_lseq_is_transposewxw #t vs0 =
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012)
val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i]) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 |
vs: Lib.Sequence.lseq (Lib.IntVector.vec_t Lib.IntTypes.U32 4) 4 ->
i: Prims.nat{i < 4} ->
j: Prims.nat{j < 4}
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntVector.vec_v (Lib.IntVector.Transpose.transpose4x4_lseq vs).[ i ]).[ j ] ==
(Lib.IntVector.vec_v vs.[ j ]).[ i ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.IntTypes.U32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntVector.vec_interleave_high_lemma_uint32_4",
"Lib.Sequence.op_String_Access",
"Prims.unit",
"Lib.IntVector.vec_interleave_low_lemma_uint32_4",
"Lib.IntVector.vec_interleave_high_n_lemma_uint32_4_2",
"Lib.IntVector.vec_interleave_low_n_lemma_uint32_4_2",
"Lib.IntVector.Transpose.transposewxw_f",
"Lib.LoopCombinators.eq_repeati0",
"Lib.LoopCombinators.unfold_repeati",
"Lib.IntVector.Transpose.transposewxw_lseq",
"Prims.int",
"Lib.IntVector.Transpose.transpose4x4_lseq_is_transposewxw"
] | [] | true | false | true | false | false | let transpose4x4_lemma_uint32_ij vs0 i j =
| transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint32_4_2 res0.[ 0 ] res0.[ 2 ];
vec_interleave_high_n_lemma_uint32_4_2 res0.[ 0 ] res0.[ 2 ];
vec_interleave_low_n_lemma_uint32_4_2 res0.[ 1 ] res0.[ 3 ];
vec_interleave_high_n_lemma_uint32_4_2 res0.[ 1 ] res0.[ 3 ];
vec_interleave_low_lemma_uint32_4 vs0.[ 0 ] vs0.[ 1 ];
vec_interleave_high_lemma_uint32_4 vs0.[ 0 ] vs0.[ 1 ];
vec_interleave_low_lemma_uint32_4 vs0.[ 2 ] vs0.[ 3 ];
vec_interleave_high_lemma_uint32_4 vs0.[ 2 ] vs0.[ 3 ] | false |
Steel.ST.Array.fst | Steel.ST.Array.gather | val gather
(#opened: _)
(#elt: Type)
(a: array elt)
(#x1: Seq.seq elt) (p1: P.perm)
(#x2: Seq.seq elt) (p2: P.perm)
: STGhost unit opened
(pts_to a p1 x1 `star` pts_to a p2 x2)
(fun _ -> pts_to a (p1 `P.sum_perm` p2) x1)
(True)
(fun _ -> x1 == x2) | val gather
(#opened: _)
(#elt: Type)
(a: array elt)
(#x1: Seq.seq elt) (p1: P.perm)
(#x2: Seq.seq elt) (p2: P.perm)
: STGhost unit opened
(pts_to a p1 x1 `star` pts_to a p2 x2)
(fun _ -> pts_to a (p1 `P.sum_perm` p2) x1)
(True)
(fun _ -> x1 == x2) | let gather
#_ #_ a #x1 p1 #x2 p2
= rewrite
(pts_to a p1 _)
(H.pts_to a p1 (seq_map raise x1));
rewrite
(pts_to a p2 _)
(H.pts_to a p2 (seq_map raise x2));
H.gather a p1 p2;
rewrite
(H.pts_to a _ _)
(pts_to _ _ _) | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 18,
"end_line": 165,
"start_col": 0,
"start_line": 154
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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.ST.Array
module US = FStar.SizeT
/// Lifting a value of universe 0 to universe 1. We use
/// FStar.Universe, since FStar.Extraction.Krml is set to extract
/// those functions to identity.
inline_for_extraction
[@@ noextract_to "krml"]
let raise_t (t: Type0) : Type u#1 = FStar.Universe.raise_t t
inline_for_extraction
[@@noextract_to "krml"]
let raise (#t: Type) (x: t) : Tot (raise_t t) =
FStar.Universe.raise_val x
inline_for_extraction
[@@noextract_to "krml"]
let lower (#t: Type) (x: raise_t t) : Tot t =
FStar.Universe.downgrade_val x
/// A map operation on sequences. Here we only need Ghost versions,
/// because such sequences are only used in vprops or with their
/// selectors.
let rec seq_map
(#t: Type u#a)
(#t' : Type u#b)
(f: (t -> GTot t'))
(s: Seq.seq t)
: Ghost (Seq.seq t')
(requires True)
(ensures (fun s' ->
Seq.length s' == Seq.length s /\
(forall i . {:pattern (Seq.index s' i)} Seq.index s' i == f (Seq.index s i))
))
(decreases (Seq.length s))
= if Seq.length s = 0
then Seq.empty
else Seq.cons (f (Seq.index s 0)) (seq_map f (Seq.slice s 1 (Seq.length s)))
let seq_map_append
(#t: Type u#a)
(#t': Type u#b)
(f: (t -> GTot t'))
(s1 s2: Seq.seq t)
: Lemma
(seq_map f (s1 `Seq.append` s2) `Seq.equal` (seq_map f s1 `Seq.append` seq_map f s2))
= ()
let seq_map_raise_inj
(#elt: Type0)
(s1 s2: Seq.seq elt)
: Lemma
(requires (seq_map raise s1 == seq_map raise s2))
(ensures (s1 == s2))
[SMTPat (seq_map raise s1); SMTPat (seq_map raise s2)]
= assert (seq_map lower (seq_map raise s1) `Seq.equal` s1);
assert (seq_map lower (seq_map raise s2) `Seq.equal` s2)
/// Implementation of the interface
/// base, ptr, array, pts_to
module H = Steel.ST.HigherArray
let base_t elt = H.base_t (raise_t elt)
let base_len b = H.base_len b
let ptr elt = H.ptr (raise_t elt)
let null_ptr elt = H.null_ptr (raise_t elt)
let is_null_ptr p = H.is_null_ptr p
let base p = H.base p
let offset p = H.offset p
let ptr_base_offset_inj p1 p2 = H.ptr_base_offset_inj p1 p2
let base_len_null_ptr elt = H.base_len_null_ptr (raise_t elt)
let length_fits a = H.length_fits a
let pts_to a p s = H.pts_to a p (seq_map raise s)
let pts_to_length a s =
H.pts_to_length a _
let h_array_eq'
(#t: Type u#1)
(a1 a2: H.array t)
: Lemma
(requires (
dfst a1 == dfst a2 /\
(Ghost.reveal (dsnd a1) <: nat) == Ghost.reveal (dsnd a2)
))
(ensures (
a1 == a2
))
= ()
let pts_to_not_null #_ #t #p a s =
let _ = H.pts_to_not_null #_ #_ #p a (seq_map raise s) in
assert (a =!= H.null #(raise_t t));
Classical.move_requires (h_array_eq' a) (H.null #(raise_t t));
noop ()
let pts_to_inj a p1 s1 p2 s2 =
H.pts_to_inj a p1 (seq_map raise s1) p2 (seq_map raise s2)
/// Non-selector operations.
let malloc x n =
let res = H.malloc (raise x) n in
assert (seq_map raise (Seq.create (US.v n) x) `Seq.equal` Seq.create (US.v n) (raise x));
rewrite
(H.pts_to res _ _)
(pts_to res _ _);
return res
let free #_ x =
let s = elim_exists () in
rewrite
(pts_to x _ _)
(H.pts_to x P.full_perm (seq_map raise s));
H.free x
let share
#_ #_ #x a p p1 p2
= rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite
(H.pts_to a p1 _)
(pts_to a p1 x);
rewrite
(H.pts_to a p2 _)
(pts_to a p2 x) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.Array.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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 |
a: Steel.ST.Array.array elt ->
p1: Steel.FractionalPermission.perm ->
p2: Steel.FractionalPermission.perm
-> Steel.ST.Effect.Ghost.STGhost Prims.unit | Steel.ST.Effect.Ghost.STGhost | [] | [] | [
"Steel.Memory.inames",
"Steel.ST.Array.array",
"FStar.Seq.Base.seq",
"Steel.FractionalPermission.perm",
"Steel.ST.Util.rewrite",
"Steel.ST.HigherArray.pts_to",
"Steel.ST.Array.raise_t",
"Steel.FractionalPermission.sum_perm",
"Steel.ST.Array.seq_map",
"Steel.ST.Array.raise",
"Steel.ST.Array.pts_to",
"Prims.unit",
"Steel.ST.HigherArray.gather"
] | [] | false | true | false | false | false | let gather #_ #_ a #x1 p1 #x2 p2 =
| rewrite (pts_to a p1 _) (H.pts_to a p1 (seq_map raise x1));
rewrite (pts_to a p2 _) (H.pts_to a p2 (seq_map raise x2));
H.gather a p1 p2;
rewrite (H.pts_to a _ _) (pts_to _ _ _) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_lemma_ | val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b) | val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b) | let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 89,
"end_line": 211,
"start_col": 0,
"start_line": 205
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t * len)
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Convert.bn_from_bytes_be_ len b) ==
Lib.ByteSequence.nat_from_bytes_be b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.uints_from_bytes_be",
"Lib.IntTypes.bits",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.ByteSequence.nat_from_bytes_be",
"Prims.unit",
"Lib.ByteSequence.uints_from_bytes_be_nat_lemma",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_",
"Hacl.Spec.Bignum.Convert.twice_reverse",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_is_uints_from_bytes_be_reverse",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_be_lemma"
] | [] | true | false | true | false | false | let bn_from_bytes_be_lemma_ #t len b =
| bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b) | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose8x8_lemma | val transpose8x8_lemma: #t:v_inttype{t = U32} -> vs:lseq (vec_t t 8) 8 ->
Lemma (forall (i:nat{i < 8}) (j:nat{j < 8}). (vec_v (transpose8x8_lseq vs).[i]).[j] == (vec_v vs.[j]).[i]) | val transpose8x8_lemma: #t:v_inttype{t = U32} -> vs:lseq (vec_t t 8) 8 ->
Lemma (forall (i:nat{i < 8}) (j:nat{j < 8}). (vec_v (transpose8x8_lseq vs).[i]).[j] == (vec_v vs.[j]).[i]) | let transpose8x8_lemma #t vs =
match t with
| U32 -> Classical.forall_intro_2 (transpose8x8_lemma_uint32_ij vs) | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 318,
"start_col": 0,
"start_line": 316
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0)
inline_for_extraction
let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7
val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012)
let transpose8x8_lseq_is_transposewxw #t vs0 =
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012)
val transpose4x4_lemma_uint32_ij: vs:lseq (vec_t U32 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose4x4_lemma_uint32_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_4 vs0.[2] vs0.[3]
val transpose4x4_lemma_uint64_ij: vs:lseq (vec_t U64 4) 4 -> i:nat{i < 4} -> j:nat{j < 4} ->
Lemma ((vec_v (transpose4x4_lseq #U64 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose4x4_lemma_uint64_ij vs0 i j =
transpose4x4_lseq_is_transposewxw vs0;
let n = 2 in
let r = transposewxw_lseq 2 vs0 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
let res0 = transposewxw_f 2 0 vs0 in
let res1 = transposewxw_f 2 1 res0 in
vec_interleave_low_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint64_4_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint64_4_2 res0.[1] res0.[3];
vec_interleave_low_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint64_4 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint64_4 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint64_4 vs0.[2] vs0.[3]
val transpose8x8_lemma_uint32_ij: vs:lseq (vec_t U32 8) 8 -> i:nat{i < 8} -> j:nat{j < 8} ->
Lemma ((vec_v (transpose8x8_lseq #U32 vs).[i]).[j] == (vec_v vs.[j]).[i])
let transpose8x8_lemma_uint32_ij vs0 i j =
transpose8x8_lseq_is_transposewxw vs0;
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
let res1 = transposewxw_f n 1 res0 in
let res2 = transposewxw_f n 2 res1 in
vec_interleave_low_n_lemma_uint32_8_4 res1.[0] res1.[4];
vec_interleave_low_n_lemma_uint32_8_4 res1.[1] res1.[5];
vec_interleave_low_n_lemma_uint32_8_4 res1.[2] res1.[6];
vec_interleave_low_n_lemma_uint32_8_4 res1.[3] res1.[7];
vec_interleave_high_n_lemma_uint32_8_4 res1.[0] res1.[4];
vec_interleave_high_n_lemma_uint32_8_4 res1.[1] res1.[5];
vec_interleave_high_n_lemma_uint32_8_4 res1.[2] res1.[6];
vec_interleave_high_n_lemma_uint32_8_4 res1.[3] res1.[7];
vec_interleave_low_n_lemma_uint32_8_2 res0.[0] res0.[2];
vec_interleave_low_n_lemma_uint32_8_2 res0.[1] res0.[3];
vec_interleave_low_n_lemma_uint32_8_2 res0.[4] res0.[6];
vec_interleave_low_n_lemma_uint32_8_2 res0.[5] res0.[7];
vec_interleave_high_n_lemma_uint32_8_2 res0.[0] res0.[2];
vec_interleave_high_n_lemma_uint32_8_2 res0.[1] res0.[3];
vec_interleave_high_n_lemma_uint32_8_2 res0.[4] res0.[6];
vec_interleave_high_n_lemma_uint32_8_2 res0.[5] res0.[7];
vec_interleave_low_lemma_uint32_8 vs0.[0] vs0.[1];
vec_interleave_low_lemma_uint32_8 vs0.[2] vs0.[3];
vec_interleave_low_lemma_uint32_8 vs0.[4] vs0.[5];
vec_interleave_low_lemma_uint32_8 vs0.[6] vs0.[7];
vec_interleave_high_lemma_uint32_8 vs0.[0] vs0.[1];
vec_interleave_high_lemma_uint32_8 vs0.[2] vs0.[3];
vec_interleave_high_lemma_uint32_8 vs0.[4] vs0.[5];
vec_interleave_high_lemma_uint32_8 vs0.[6] vs0.[7]
let transpose4x4_lemma #t vs =
match t with
| U32 -> Classical.forall_intro_2 (transpose4x4_lemma_uint32_ij vs)
| U64 -> Classical.forall_intro_2 (transpose4x4_lemma_uint64_ij vs) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8
-> FStar.Pervasives.Lemma
(ensures
forall (i: Prims.nat{i < 8}) (j: Prims.nat{j < 8}).
(Lib.IntVector.vec_v (Lib.IntVector.Transpose.transpose8x8_lseq vs).[ i ]).[ j ] ==
(Lib.IntVector.vec_v vs.[ j ]).[ i ]) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Prims.b2t",
"Prims.op_Equality",
"Lib.IntTypes.inttype",
"Lib.IntTypes.U32",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"FStar.Classical.forall_intro_2",
"Prims.nat",
"Prims.op_LessThan",
"Prims.eq2",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntVector.vec_v",
"Lib.Sequence.op_String_Access",
"Lib.IntVector.Transpose.transpose8x8_lseq",
"Lib.IntVector.Transpose.transpose8x8_lemma_uint32_ij",
"Prims.unit"
] | [] | false | false | true | false | false | let transpose8x8_lemma #t vs =
| match t with | U32 -> Classical.forall_intro_2 (transpose8x8_lemma_uint32_ij vs) | false |
SelectorsLList3Example.fst | SelectorsLList3Example.mk_cell | val mk_cell (n: t) (d: a) : Pure cell (requires True) (ensures fun c -> next c == n /\ data c == d) | val mk_cell (n: t) (d: a) : Pure cell (requires True) (ensures fun c -> next c == n /\ data c == d) | let mk_cell (n: t) (d:a)
: Pure cell
(requires True)
(ensures fun c ->
next c == n /\
data c == d)
= LL.mk_cell n d | {
"file_name": "share/steel/examples/steel/llist3/SelectorsLList3Example.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 27,
"start_col": 0,
"start_line": 21
} | module SelectorsLList3Example
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open Steel.ArrayRef
module L = FStar.List.Tot
module LL = Selectors.LList3
module U32 = FStar.UInt32
module MB = LowStar.Monotonic.Buffer // for is_null
inline_for_extraction noextract let a = U32.t
let cell = LL.cell a
/// The type of a list: A reference to a cell
let t = LL.t a
let next (c:cell) : t = LL.next c | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"Steel.ArrayRef.fsti.checked",
"Selectors.LList3.fsti.checked",
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "SelectorsLList3Example.fst"
} | [
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer // for is_null",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "MB"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "Selectors.LList3",
"short_module": "LL"
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.ArrayRef",
"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.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: SelectorsLList3Example.t -> d: SelectorsLList3Example.a -> Prims.Pure SelectorsLList3Example.cell | Prims.Pure | [] | [] | [
"SelectorsLList3Example.t",
"SelectorsLList3Example.a",
"Selectors.LList3.mk_cell",
"SelectorsLList3Example.cell",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"SelectorsLList3Example.next",
"SelectorsLList3Example.data"
] | [] | false | false | false | false | false | let mk_cell (n: t) (d: a) : Pure cell (requires True) (ensures fun c -> next c == n /\ data c == d) =
| LL.mk_cell n d | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_be_zeroes | val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0) | val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0) | let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 223,
"start_col": 0,
"start_line": 218
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_nat -> b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.nat). i < len ==> b.[ i ] == Lib.IntTypes.u8 0)
(ensures Lib.ByteSequence.nat_from_intseq_be b == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.size_nat",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_be_zeroes",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Prims.unit",
"Lib.ByteSequence.nat_from_intseq_be_lemma0",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_from_intseq_be_slice_lemma"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_nat_from_bytes_be_zeroes len b =
| if len = 0
then ()
else
(nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len - 1) (slice b 1 len)) | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.refl_ext_point | val refl_ext_point (a: LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point | val refl_ext_point (a: LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point | let refl_ext_point (a:LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point =
let open Hacl.Spec.Curve25519.Field51.Definition in
let x = feval (lseq_as_felem (LSeq.sub a 0 5)) in
let y = feval (lseq_as_felem (LSeq.sub a 5 5)) in
let z = feval (lseq_as_felem (LSeq.sub a 10 5)) in
let t = feval (lseq_as_felem (LSeq.sub a 15 5)) in
(x, y, z, t) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 62,
"start_col": 0,
"start_line": 56
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul)
unfold
let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4]) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 20 -> Prims.GTot Spec.Ed25519.PointOps.ext_point | Prims.GTot | [
"sometrivial"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.Mktuple4",
"Spec.Curve25519.elem",
"Hacl.Spec.Curve25519.Field51.Definition.feval",
"Hacl.Impl.Ed25519.Field51.lseq_as_felem",
"Lib.Sequence.sub",
"Spec.Ed25519.PointOps.ext_point"
] | [] | false | false | false | false | false | let refl_ext_point (a: LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point =
| let open Hacl.Spec.Curve25519.Field51.Definition in
let x = feval (lseq_as_felem (LSeq.sub a 0 5)) in
let y = feval (lseq_as_felem (LSeq.sub a 5 5)) in
let z = feval (lseq_as_felem (LSeq.sub a 10 5)) in
let t = feval (lseq_as_felem (LSeq.sub a 15 5)) in
(x, y, z, t) | false |
Steel.ST.Array.fst | Steel.ST.Array.index | val index
(#t: Type) (#p: P.perm)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t)
: ST t
(pts_to a p s)
(fun _ -> pts_to a p s)
(US.v i < length a \/ US.v i < Seq.length s)
(fun res -> Seq.length s == length a /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i)) | val index
(#t: Type) (#p: P.perm)
(a: array t)
(#s: Ghost.erased (Seq.seq t))
(i: US.t)
: ST t
(pts_to a p s)
(fun _ -> pts_to a p s)
(US.v i < length a \/ US.v i < Seq.length s)
(fun res -> Seq.length s == length a /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i)) | let index #_ #p a #s i =
rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise s));
let res = H.index a i in
rewrite
(H.pts_to _ _ _)
(pts_to _ _ _);
return (lower res) | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 20,
"end_line": 175,
"start_col": 0,
"start_line": 167
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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.ST.Array
module US = FStar.SizeT
/// Lifting a value of universe 0 to universe 1. We use
/// FStar.Universe, since FStar.Extraction.Krml is set to extract
/// those functions to identity.
inline_for_extraction
[@@ noextract_to "krml"]
let raise_t (t: Type0) : Type u#1 = FStar.Universe.raise_t t
inline_for_extraction
[@@noextract_to "krml"]
let raise (#t: Type) (x: t) : Tot (raise_t t) =
FStar.Universe.raise_val x
inline_for_extraction
[@@noextract_to "krml"]
let lower (#t: Type) (x: raise_t t) : Tot t =
FStar.Universe.downgrade_val x
/// A map operation on sequences. Here we only need Ghost versions,
/// because such sequences are only used in vprops or with their
/// selectors.
let rec seq_map
(#t: Type u#a)
(#t' : Type u#b)
(f: (t -> GTot t'))
(s: Seq.seq t)
: Ghost (Seq.seq t')
(requires True)
(ensures (fun s' ->
Seq.length s' == Seq.length s /\
(forall i . {:pattern (Seq.index s' i)} Seq.index s' i == f (Seq.index s i))
))
(decreases (Seq.length s))
= if Seq.length s = 0
then Seq.empty
else Seq.cons (f (Seq.index s 0)) (seq_map f (Seq.slice s 1 (Seq.length s)))
let seq_map_append
(#t: Type u#a)
(#t': Type u#b)
(f: (t -> GTot t'))
(s1 s2: Seq.seq t)
: Lemma
(seq_map f (s1 `Seq.append` s2) `Seq.equal` (seq_map f s1 `Seq.append` seq_map f s2))
= ()
let seq_map_raise_inj
(#elt: Type0)
(s1 s2: Seq.seq elt)
: Lemma
(requires (seq_map raise s1 == seq_map raise s2))
(ensures (s1 == s2))
[SMTPat (seq_map raise s1); SMTPat (seq_map raise s2)]
= assert (seq_map lower (seq_map raise s1) `Seq.equal` s1);
assert (seq_map lower (seq_map raise s2) `Seq.equal` s2)
/// Implementation of the interface
/// base, ptr, array, pts_to
module H = Steel.ST.HigherArray
let base_t elt = H.base_t (raise_t elt)
let base_len b = H.base_len b
let ptr elt = H.ptr (raise_t elt)
let null_ptr elt = H.null_ptr (raise_t elt)
let is_null_ptr p = H.is_null_ptr p
let base p = H.base p
let offset p = H.offset p
let ptr_base_offset_inj p1 p2 = H.ptr_base_offset_inj p1 p2
let base_len_null_ptr elt = H.base_len_null_ptr (raise_t elt)
let length_fits a = H.length_fits a
let pts_to a p s = H.pts_to a p (seq_map raise s)
let pts_to_length a s =
H.pts_to_length a _
let h_array_eq'
(#t: Type u#1)
(a1 a2: H.array t)
: Lemma
(requires (
dfst a1 == dfst a2 /\
(Ghost.reveal (dsnd a1) <: nat) == Ghost.reveal (dsnd a2)
))
(ensures (
a1 == a2
))
= ()
let pts_to_not_null #_ #t #p a s =
let _ = H.pts_to_not_null #_ #_ #p a (seq_map raise s) in
assert (a =!= H.null #(raise_t t));
Classical.move_requires (h_array_eq' a) (H.null #(raise_t t));
noop ()
let pts_to_inj a p1 s1 p2 s2 =
H.pts_to_inj a p1 (seq_map raise s1) p2 (seq_map raise s2)
/// Non-selector operations.
let malloc x n =
let res = H.malloc (raise x) n in
assert (seq_map raise (Seq.create (US.v n) x) `Seq.equal` Seq.create (US.v n) (raise x));
rewrite
(H.pts_to res _ _)
(pts_to res _ _);
return res
let free #_ x =
let s = elim_exists () in
rewrite
(pts_to x _ _)
(H.pts_to x P.full_perm (seq_map raise s));
H.free x
let share
#_ #_ #x a p p1 p2
= rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite
(H.pts_to a p1 _)
(pts_to a p1 x);
rewrite
(H.pts_to a p2 _)
(pts_to a p2 x)
let gather
#_ #_ a #x1 p1 #x2 p2
= rewrite
(pts_to a p1 _)
(H.pts_to a p1 (seq_map raise x1));
rewrite
(pts_to a p2 _)
(H.pts_to a p2 (seq_map raise x2));
H.gather a p1 p2;
rewrite
(H.pts_to a _ _)
(pts_to _ _ _) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.Array.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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 | a: Steel.ST.Array.array t -> i: FStar.SizeT.t -> Steel.ST.Effect.ST t | Steel.ST.Effect.ST | [] | [] | [
"Steel.FractionalPermission.perm",
"Steel.ST.Array.array",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.SizeT.t",
"Steel.ST.Util.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.ST.Array.pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Steel.ST.Array.lower",
"Prims.unit",
"Steel.ST.Util.rewrite",
"Steel.ST.HigherArray.pts_to",
"Steel.ST.Array.raise_t",
"Steel.ST.Array.seq_map",
"Steel.ST.Array.raise",
"Steel.ST.HigherArray.index"
] | [] | false | true | false | false | false | let index #_ #p a #s i =
| rewrite (pts_to a _ _) (H.pts_to a p (seq_map raise s));
let res = H.index a i in
rewrite (H.pts_to _ _ _) (pts_to _ _ _);
return (lower res) | false |
Hacl.Impl.Curve25519.Fields.Core.fsti | Hacl.Impl.Curve25519.Fields.Core.fsqr2_t | val fsqr2_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | let fsqr2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f /\ live h tmp /\
(disjoint out f \/ out == f) /\
(disjoint out tmp) /\
disjoint tmp f /\
fsqr2_pre h f)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2))) | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 357,
"start_col": 0,
"start_line": 338
} | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True
inline_for_extraction
let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21)))
[@ Meta.Attribute.specialize ]
val fmul2: #s:field_spec -> fmul2_t s True
let fmul1_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:uint64): Type0 =
match s with
| M51 -> f51_felem_fits h f1 (9, 10, 9, 9, 9) /\ f51_felem_fits1 f2 1
| M64 -> v f2 < pow2 17
inline_for_extraction
let fmul1_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:uint64
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\
(disjoint out f1 \/ out == f1) /\
fmul1_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (v f2))
// feval h1 out == (feval h0 f1 * v f2) % P.prime)
[@ Meta.Attribute.specialize ]
val fmul1: #s:field_spec -> fmul1_t s True
let fsqr_pre (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h f (9, 10, 9, 9, 9)
| M64 -> True
let fsqr_disjoint (#s:field_spec) (out f1:felem s) (tmp:felem_wide s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out tmp \/ out == tmp) /\
disjoint tmp f1
inline_for_extraction
let fsqr_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> tmp:felem_wide s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h tmp /\
fsqr_disjoint out f1 tmp /\
fsqr_pre h f1)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\
state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f1))
[@ Meta.Attribute.specialize ]
val fsqr: #s:field_spec -> fsqr_t s True
let fsqr2_pre (#s:field_spec) (h:mem) (f:felem2 s): Type0 =
match s with
| M51 ->
let f1 = gsub f 0ul 5ul in
let f2 = gsub f 5ul 5ul in
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True | {
"checked_file": "/",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"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": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fsqr2_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_fsqr2_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | true | let fsqr2_t (s: field_spec) (p: Type0) =
| out: felem2 s -> f: felem2 s -> tmp: felem_wide2 s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f /\ live h tmp /\ (disjoint out f \/ out == f) /\
(disjoint out tmp) /\ disjoint tmp f /\ fsqr2_pre h f)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out1 = gsub out 0ul (nlimb s) in
let out2 = gsub out (nlimb s) (nlimb s) in
let f1 = gsub f 0ul (nlimb s) in
let f2 = gsub f (nlimb s) (nlimb s) in
feval h1 out1 == P.fmul (feval h0 f1) (feval h0 f1) /\
feval h1 out2 == P.fmul (feval h0 f2) (feval h0 f2))) | false |
|
Hacl.Impl.Curve25519.Fields.Core.fsti | Hacl.Impl.Curve25519.Fields.Core.fmul2_t | val fmul2_t : s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | let fmul2_t (s:field_spec) (p: Type0) =
out:felem2 s
-> f1:felem2 s
-> f2:felem2 s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp /\
fmul2_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21))) | {
"file_name": "code/curve25519/Hacl.Impl.Curve25519.Fields.Core.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 267,
"start_col": 0,
"start_line": 242
} | module Hacl.Impl.Curve25519.Fields.Core
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open Lib.Buffer
module P = Spec.Curve25519
/// This module defines the core functions for which we will want to swap out
/// implementations. They are marked as assume val's since we strictly have more
/// than one implementation per index value.
#set-options "--z3rlimit 50 --fuel 0 --ifuel 1 --record_options"
/// Shared definitions for agility of the field type
/// ------------------------------------------------
type field_spec =
| M51
| M64
unfold noextract
let limb (s:field_spec) =
match s with
| M51 -> uint64
| M64 -> uint64
unfold noextract
let limb_zero (s:field_spec) : limb s=
match s with
| M51 -> u64 0
| M64 -> u64 0
unfold noextract
let nlimb (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 4ul
unfold noextract
let wide (s:field_spec) =
match s with
| M51 -> uint128
| M64 -> uint64
unfold noextract
let wide_zero (s:field_spec) : wide s=
match s with
| M51 -> u128 0
| M64 -> u64 0
unfold noextract
let nwide (s:field_spec) : size_t =
match s with
| M51 -> 5ul
| M64 -> 8ul
inline_for_extraction noextract
let felem (s:field_spec) = lbuffer (limb s) (nlimb s)
inline_for_extraction noextract
let felem2 (s:field_spec) = lbuffer (limb s) (nlimb s +. nlimb s)
inline_for_extraction noextract
let felem_wide (s:field_spec) = lbuffer (wide s) (nwide s)
inline_for_extraction noextract
let felem_wide2 (s:field_spec) = lbuffer (wide s) (nwide s +. nwide s)
/// Introduce representation for each field + helpers to be able to state pre & posts
/// ---------------------------------------------------------------------------------
noextract
let f51_as_felem (h:mem) (f:felem M51) : GTot Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let s = as_seq h f in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
let s4 = s.[4] in
(s0, s1, s2, s3, s4)
let f51_as_nat h e = Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (f51_as_felem h e)
noextract
let f51_felem_fits (h:mem) (f:felem M51) (m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5): Type0 =
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 (f51_as_felem h f) m
noextract
let f51_felem_fits1 = Hacl.Spec.Curve25519.Field51.Definition.felem_fits1
noextract
let f51_mul_inv_t (h:mem) (f:felem M51) : GTot Type0 =
let f = f51_as_felem h f in
Hacl.Spec.Curve25519.Field51.mul_inv_t f
noextract
let f64_as_nat (h:mem) (e: felem M64) : GTot nat =
let s = as_seq h e in
let s0 = s.[0] in
let s1 = s.[1] in
let s2 = s.[2] in
let s3 = s.[3] in
Hacl.Spec.Curve25519.Field64.Definition.as_nat4 (s0, s1, s2, s3)
noextract
let as_nat (#s:field_spec) (h:mem) (e:felem s): GTot nat =
match s with
| M51 -> f51_as_nat h e
| M64 -> f64_as_nat h e
noextract
let feval (#s:field_spec) (h:mem) (e:felem s): GTot P.elem =
(as_nat h e) % P.prime
/// Start of core combinators
/// -------------------------
let fadd_fsub_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (1, 2, 1, 1, 1) /\
f51_felem_fits h f2 (1, 2, 1, 1, 1)
| M64 -> True
let fadd_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (2, 4, 2, 2, 2)
| M64 -> True
inline_for_extraction
let fadd_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fadd_post h1 out /\
feval h1 out == P.fadd (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize]
val fadd: #s:field_spec -> fadd_t s True
let fsub_post (#s:field_spec) (h:mem) (out:felem s): Type0 =
match s with
| M51 -> f51_felem_fits h out (9, 10, 9, 9, 9)
| M64 -> True
inline_for_extraction
let fsub_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint f1 f2 \/ f1 == f2) /\
fadd_fsub_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\ fsub_post h1 out /\
feval h1 out == P.fsub (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fsub: #s:field_spec -> fsub_t s True
let fmul_pre (#s:field_spec) (h:mem) (f1:felem s) (f2:felem s): Type0 =
match s with
| M51 ->
f51_felem_fits h f1 (9, 10, 9, 9, 9) /\
f51_felem_fits h f2 (9, 10, 9, 9, 9)
| M64 -> True
let fmul_disjoint (#s:field_spec) (out f1 f2:felem s) (tmp:felem_wide2 s): Type0 =
match s with
| M51 -> True
| M64 ->
(disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\
(disjoint out tmp \/ out == tmp) /\
(disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\
disjoint f2 tmp
let state_inv_t (#s:field_spec) (h:mem) (f:felem s): Type0 =
match s with
| M51 -> f51_mul_inv_t h f
| M64 -> True
inline_for_extraction
let fmul_t (s:field_spec) (p: Type0) =
out:felem s
-> f1:felem s
-> f2:felem s
-> tmp:felem_wide2 s
-> Stack unit
(requires fun h ->
p /\
live h out /\ live h f1 /\ live h f2 /\ live h tmp /\
fmul_disjoint out f1 f2 tmp /\
fmul_pre h f1 f2)
(ensures fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ state_inv_t h1 out /\
feval h1 out == P.fmul (feval h0 f1) (feval h0 f2))
[@ Meta.Attribute.specialize ]
val fmul: #s:field_spec -> fmul_t s True
let fmul2_pre (#s:field_spec) (h:mem) (f1:felem2 s) (f2:felem2 s): Type0 =
match s with
| M51 ->
let f10 = gsub f1 0ul 5ul in
let f11 = gsub f1 5ul 5ul in
let f20 = gsub f2 0ul 5ul in
let f21 = gsub f2 5ul 5ul in
f51_felem_fits h f10 (9, 10, 9, 9, 9) /\
f51_felem_fits h f11 (9, 10, 9, 9, 9) /\
f51_felem_fits h f20 (9, 10, 9, 9, 9) /\
f51_felem_fits h f21 (9, 10, 9, 9, 9)
| M64 -> True
let fmul2_fsqr2_post (#s:field_spec) (h:mem) (out:felem2 s): Type0 =
match s with
| M51 ->
let out0 = gsub out 0ul 5ul in
let out1 = gsub out 5ul 5ul in
f51_mul_inv_t h out0 /\
f51_mul_inv_t h out1
| M64 -> True | {
"checked_file": "/",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Meta.Attribute.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field64.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Curve25519.Fields.Core.fsti"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"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": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | s: Hacl.Impl.Curve25519.Fields.Core.field_spec -> p: Type0 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Curve25519.Fields.Core.field_spec",
"Hacl.Impl.Curve25519.Fields.Core.felem2",
"Hacl.Impl.Curve25519.Fields.Core.felem_wide2",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Hacl.Impl.Curve25519.Fields.Core.limb",
"Hacl.Impl.Curve25519.Fields.Core.wide",
"Prims.l_or",
"Lib.Buffer.disjoint",
"Prims.eq2",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_pre",
"Lib.Buffer.modifies",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Hacl.Impl.Curve25519.Fields.Core.fmul2_fsqr2_post",
"Spec.Curve25519.elem",
"Hacl.Impl.Curve25519.Fields.Core.feval",
"Spec.Curve25519.fmul",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.gsub",
"Lib.IntTypes.op_Plus_Dot",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Curve25519.Fields.Core.nlimb",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | true | let fmul2_t (s: field_spec) (p: Type0) =
| out: felem2 s -> f1: felem2 s -> f2: felem2 s -> tmp: felem_wide2 s
-> Stack unit
(requires
fun h ->
p /\ live h out /\ live h f1 /\ live h f2 /\ live h tmp /\ (disjoint out f1 \/ out == f1) /\
(disjoint out f2 \/ out == f2) /\ (disjoint out tmp) /\ (disjoint f1 f2 \/ f1 == f2) /\
disjoint f1 tmp /\ disjoint f2 tmp /\ fmul2_pre h f1 f2)
(ensures
fun h0 _ h1 ->
modifies (loc out |+| loc tmp) h0 h1 /\ fmul2_fsqr2_post h1 out /\
(let out0 = gsub out 0ul (nlimb s) in
let out1 = gsub out (nlimb s) (nlimb s) in
let f10 = gsub f1 0ul (nlimb s) in
let f11 = gsub f1 (nlimb s) (nlimb s) in
let f20 = gsub f2 0ul (nlimb s) in
let f21 = gsub f2 (nlimb s) (nlimb s) in
feval h1 out0 == P.fmul (feval h0 f10) (feval h0 f20) /\
feval h1 out1 == P.fmul (feval h0 f11) (feval h0 f21))) | false |
|
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.nat_from_bytes_be_eq_lemma | val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b)) | val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b)) | let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 238,
"start_col": 0,
"start_line": 230
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len0: Lib.IntTypes.size_nat ->
len: Lib.IntTypes.size_nat{len0 <= len} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len0
-> FStar.Pervasives.Lemma
(ensures
(let tmp = Lib.Sequence.create len (Lib.IntTypes.u8 0) in
Lib.ByteSequence.nat_from_intseq_be b ==
Lib.ByteSequence.nat_from_intseq_be (Lib.Sequence.update_sub tmp (len - len0) len0 b))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_be_zeroes",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.Sequence.slice",
"Lib.ByteSequence.nat_from_intseq_be_slice_lemma",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.u8",
"Lib.Sequence.seq",
"Prims.l_and",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq",
"Lib.Sequence.index",
"Lib.IntTypes.int_t",
"Lib.Sequence.sub",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.Sequence.create"
] | [] | false | false | true | false | false | let nat_from_bytes_be_eq_lemma len0 len b =
| let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i: nat). i < len - len0 ==> r.[ i ] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r ==
nat_from_intseq_be (slice r (len - len0) len) +
pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r ==
nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0)) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_le_lemma | val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b) | val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b) | let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 106,
"end_line": 385,
"start_col": 0,
"start_line": 371
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_nat -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures Hacl.Spec.Bignum.Definitions.bn_v b == Lib.ByteSequence.nat_from_intseq_le b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.bool",
"Prims._assert",
"Prims.eq2",
"Lib.ByteSequence.nat_from_intseq_le",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.op_Subtraction",
"Lib.IntTypes.bits",
"Lib.IntTypes.v",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.unit",
"Lib.ByteSequence.nat_from_intseq_le_lemma0",
"Lib.Sequence.slice",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.nat",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_le_lemma",
"Lib.Sequence.lseq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.index"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
| if len = 0
then bn_eval0 b
else
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[ len - 1 ]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b ==
nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[ len - 1 ]) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.reverse_slice1 | val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1))) | val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1))) | let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1))) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 155,
"start_col": 0,
"start_line": 150
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Lib.Sequence.slice (Hacl.Spec.Bignum.Convert.reverse b) 1 len ==
Hacl.Spec.Bignum.Convert.reverse (Lib.Sequence.slice b 0 (len - 1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Convert.reverse",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Prims.l_True",
"Prims.squash",
"Lib.Sequence.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let reverse_slice1 #t #len b =
| let lemma_aux (i: nat{i < len - 1})
: Lemma ((slice (reverse b) 1 len).[ i ] == (reverse (slice b 0 (len - 1))).[ i ]) =
()
in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1))) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_lemma | val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b) | val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b) | let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 255,
"start_col": 0,
"start_line": 247
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Convert.bn_from_bytes_be len b) ==
Lib.ByteSequence.nat_from_bytes_be b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.nat_from_bytes_be_eq_lemma",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_lemma_",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Prims.l_and",
"Lib.Sequence.sub",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Prims.int",
"Prims.pos",
"Prims.pow2",
"Prims.op_Multiply"
] | [] | true | false | true | false | false | let bn_from_bytes_be_lemma #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_is_uints_from_bytes_be_reverse | val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b)) | val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b)) | let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 70,
"end_line": 171,
"start_col": 0,
"start_line": 164
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 (Lib.IntTypes.numbytes t * len)
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.bn_from_bytes_be_ len b ==
Hacl.Spec.Bignum.Convert.reverse (Lib.ByteSequence.uints_from_bytes_be b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.Sequence.eq_intro",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_",
"Hacl.Spec.Bignum.Convert.reverse",
"Lib.ByteSequence.uints_from_bytes_be",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Prims.l_True",
"Prims.squash",
"Lib.Sequence.index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Lib.ByteSequence.index_uints_from_bytes_be",
"Prims.op_Subtraction"
] | [] | false | false | true | false | false | let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
| let lemma_aux (i: nat{i < len})
: Lemma ((bn_from_bytes_be_ len b).[ i ] == (reverse #t #len (uints_from_bytes_be b)).[ i ]) =
index_uints_from_bytes_be #t #SEC #len b (len - i - 1)
in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b)) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_be_lemma | val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b)) | val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b)) | let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 196,
"start_col": 0,
"start_line": 177
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_nat -> b: Hacl.Spec.Bignum.Definitions.lbignum t len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v b ==
Lib.ByteSequence.nat_from_intseq_be (Hacl.Spec.Bignum.Convert.reverse b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Equality",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Prims.bool",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Convert.reverse",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.Sequence.slice",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.IntTypes.bits",
"Lib.IntTypes.v",
"Lib.Sequence.op_String_Access",
"Prims.op_Subtraction",
"Lib.ByteSequence.nat_from_intseq_be_lemma0",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Hacl.Spec.Bignum.Convert.reverse_slice1",
"Lib.ByteSequence.nat_from_intseq_be_slice_lemma",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_be_lemma",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Lib.Sequence.index"
] | [
"recursion"
] | false | false | true | false | false | let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
| if len = 0
then bn_eval0 b
else
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[ len - 1 ]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[ len - 1 ]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[ 0 ] == b.[ len - 1 ]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[ len - 1 ]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_le_zeroes | val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0) | val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0) | let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 397,
"start_col": 0,
"start_line": 392
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 | len: Lib.IntTypes.size_nat -> b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.nat). i < len ==> b.[ i ] == Lib.IntTypes.u8 0)
(ensures Lib.ByteSequence.nat_from_intseq_le b == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.size_nat",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_le_zeroes",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Prims.unit",
"Lib.ByteSequence.nat_from_intseq_le_lemma0",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_nat_from_bytes_le_zeroes len b =
| if len = 0
then ()
else
(nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len - 1) (slice b 1 len)) | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.lseq_as_felem | val lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 | val lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 | let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4]) | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 53,
"start_col": 0,
"start_line": 51
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> Hacl.Spec.Curve25519.Field51.Definition.felem5 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"FStar.Pervasives.Native.Mktuple5",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Curve25519.Field51.Definition.felem5"
] | [] | false | false | false | false | false | let lseq_as_felem (a: LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
| let open Lib.Sequence in (a.[ 0 ], a.[ 1 ], a.[ 2 ], a.[ 3 ], a.[ 4 ]) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.index_bn_to_bytes_be_ | val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)) | val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)) | let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 111,
"end_line": 273,
"start_col": 0,
"start_line": 267
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_nat{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b: Hacl.Spec.Bignum.Definitions.lbignum t len ->
i: Prims.nat{i < Lib.IntTypes.numbytes t * len}
-> FStar.Pervasives.Lemma
(ensures
(let numb = Lib.IntTypes.numbytes t in
(Hacl.Spec.Bignum.Convert.bn_to_bytes_be_ len b).[ i ] ==
Lib.IntTypes.uint (Lib.IntTypes.v b.[ len - i / numb - 1 ] /
Prims.pow2 (8 * (numb - 1 - i % numb)) %
Prims.pow2 8))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_LessThan",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_or",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.pow2",
"Prims.op_Subtraction",
"Lib.IntTypes.uint_t",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.ByteSequence.uint_to_bytes_be",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint",
"Prims.unit",
"Lib.ByteSequence.index_uint_to_bytes_be",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_",
"Lib.Sequence.index_generate_blocks",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_f",
"Hacl.Spec.Bignum.Definitions.limb"
] | [] | true | false | true | false | false | let index_bn_to_bytes_be_ #t len b i =
| let numb = numbytes t in
let bi = b.[ len - i / numb - 1 ] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[ i ] == (uint_to_bytes_be bi).[ i % numb ]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[ i % numb ] ==
uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.nat_from_bytes_le_eq_lemma | val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b)) | val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b)) | let nat_from_bytes_le_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i:nat). i < len - len0 ==> r.[len0 + i] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r == nat_from_intseq_le (slice r 0 len0) + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r == nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 412,
"start_col": 0,
"start_line": 404
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0)
let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len0: Lib.IntTypes.size_nat ->
len: Lib.IntTypes.size_nat{len0 <= len} ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len0
-> FStar.Pervasives.Lemma
(ensures
(let tmp = Lib.Sequence.create len (Lib.IntTypes.u8 0) in
Lib.ByteSequence.nat_from_intseq_le b ==
Lib.ByteSequence.nat_from_intseq_le (Lib.Sequence.update_sub tmp 0 len0 b))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.lemma_nat_from_bytes_le_zeroes",
"Prims.op_Subtraction",
"FStar.Seq.Base.slice",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.ByteSequence.nat_from_intseq_le",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.Sequence.slice",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.u8",
"Lib.Sequence.seq",
"Prims.l_and",
"FStar.Seq.Base.length",
"FStar.Seq.Base.seq",
"Lib.Sequence.index",
"Lib.IntTypes.int_t",
"Lib.Sequence.sub",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.Sequence.create"
] | [] | false | false | true | false | false | let nat_from_bytes_le_eq_lemma len0 len b =
| let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i: nat). i < len - len0 ==> r.[ len0 + i ] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r ==
nat_from_intseq_le (slice r 0 len0) +
pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r ==
nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_le_lemma | val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b) | val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b) | let bn_from_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
let res = uints_from_bytes_le #t #SEC #bnLen tmp in
uints_from_bytes_le_nat_lemma #t #SEC #bnLen tmp;
bn_v_is_nat_from_intseq_le_lemma bnLen res;
nat_from_bytes_le_eq_lemma len tmpLen b | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 429,
"start_col": 0,
"start_line": 421
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0)
let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b))
let nat_from_bytes_le_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i:nat). i < len - len0 ==> r.[len0 + i] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r == nat_from_intseq_le (slice r 0 len0) + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r == nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len)
val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Convert.bn_from_bytes_le len b) ==
Lib.ByteSequence.nat_from_bytes_le b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.nat_from_bytes_le_eq_lemma",
"Prims.unit",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_le_lemma",
"Lib.ByteSequence.uints_from_bytes_le_nat_lemma",
"Lib.IntTypes.SEC",
"Lib.IntTypes.int_t",
"Lib.ByteSequence.uints_from_bytes_le",
"Lib.IntTypes.U8",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Prims.int",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_Multiply"
] | [] | true | false | true | false | false | let bn_from_bytes_le_lemma #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
let res = uints_from_bytes_le #t #SEC #bnLen tmp in
uints_from_bytes_le_nat_lemma #t #SEC #bnLen tmp;
bn_v_is_nat_from_intseq_le_lemma bnLen res;
nat_from_bytes_le_eq_lemma len tmpLen b | false |
Hacl.Spec.K256.Field52.Definitions.Lemmas.fst | Hacl.Spec.K256.Field52.Definitions.Lemmas.as_nat_mod_prime | val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | let as_nat_mod_prime t0 t1 t2 t3 t4 =
calc (==) {
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime;
(==) { Math.Lemmas.euclidean_division_definition t4 (pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 / pow2 48 * pow2 48 + t4 % pow2 48) * pow208) % S.prime;
(==) { Math.Lemmas.distributivity_add_left (t4 / pow2 48 * pow2 48) (t4 % pow2 48) pow208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 / pow2 48 * pow2 48 * pow208 + t4 % pow2 48 * pow208) % S.prime;
(==) { Math.Lemmas.paren_mul_right (t4 / pow2 48) (pow2 48) pow208; Math.Lemmas.pow2_plus 48 208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 / pow2 48 * pow2 256 + t4 % pow2 48 * pow208) % S.prime;
(==) { lemma_a_plus_b_mul_pow256 (t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 % pow2 48 * pow208) (t4 / pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 % pow2 48 * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime;
} | {
"file_name": "code/k256/Hacl.Spec.K256.Field52.Definitions.Lemmas.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 391,
"start_col": 0,
"start_line": 380
} | module Hacl.Spec.K256.Field52.Definitions.Lemmas
open FStar.Mul
open Lib.IntTypes
open Hacl.Spec.K256.Field52.Definitions
module LSeq = Lib.Sequence
module BSeq = Lib.ByteSequence
module S = Spec.K256
module ML = Hacl.Spec.K256.MathLemmas
#set-options "--z3rlimit 100 --fuel 0 --ifuel 0"
val lemma_as_nat_mod2: x:felem5 ->
Lemma (let (x0,x1,x2,x3,x4) = x in as_nat5 x % 2 = v x0 % 2)
let lemma_as_nat_mod2 x =
let (x0,x1,x2,x3,x4) = x in
assert (as_nat5 x = v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208);
assert (as_nat5 x % 2 = (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156 + v x4 * pow208) % 2);
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104 + v x3 * pow156) (v x4) 208;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52 + v x2 * pow104) (v x3) 156;
ML.lemma_a_plus_b_pow2_mod2 (v x0 + v x1 * pow52) (v x2) 104;
ML.lemma_a_plus_b_pow2_mod2 (v x0) (v x1) 52;
assert (as_nat5 x % 2 = v x0 % 2)
val lemma_nat_from_bytes_be_mod2: f:LSeq.lseq uint8 32 ->
Lemma (BSeq.nat_from_bytes_be f % 2 = v (LSeq.index f 31) % 2)
let lemma_nat_from_bytes_be_mod2 f =
let x0 = LSeq.index f 31 in
BSeq.nat_from_intseq_be_slice_lemma f 31;
BSeq.nat_from_intseq_be_lemma0 (LSeq.slice f 31 32);
assert (BSeq.nat_from_intseq_be f == v x0 + pow2 8 * BSeq.nat_from_intseq_be (LSeq.slice f 0 31));
ML.lemma_a_plus_b_pow2_mod2 (v x0) (BSeq.nat_from_intseq_be (LSeq.slice f 0 31)) 8
val unfold_nat_from_uint64_four: b:LSeq.lseq uint64 4 ->
Lemma (BSeq.nat_from_intseq_be b ==
v (LSeq.index b 3) + v (LSeq.index b 2) * pow2 64 +
v (LSeq.index b 1) * pow2 128 + v (LSeq.index b 0) * pow2 192)
let unfold_nat_from_uint64_four b =
let b0 = v (LSeq.index b 0) in
let b1 = v (LSeq.index b 1) in
let b2 = v (LSeq.index b 2) in
let b3 = v (LSeq.index b 3) in
let res = BSeq.nat_from_intseq_be b in
BSeq.nat_from_intseq_be_slice_lemma b 3;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 3 4);
assert (res == b3 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 3)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #3 (Seq.slice b 0 3) 2;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 2 3);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 3) == b2 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 2)));
BSeq.nat_from_intseq_be_slice_lemma #U64 #SEC #2 (Seq.slice b 0 2) 1;
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 1 2);
assert (BSeq.nat_from_intseq_be (Seq.slice b 0 2) == b1 + pow2 64 * (BSeq.nat_from_intseq_be (Seq.slice b 0 1)));
BSeq.nat_from_intseq_be_lemma0 (Seq.slice b 0 1);
assert (res == b3 + pow2 64 * (b2 + pow2 64 * (b1 + pow2 64 * b0)));
ML.lemma_as_nat64_horner b3 b2 b1 b0
val lemma_prime : unit -> Lemma (pow2 256 % S.prime = 0x1000003D1)
let lemma_prime () = ()
val lemma_pow2_256_minus_prime : unit -> Lemma (pow2 256 - S.prime = 0x1000003D1)
let lemma_pow2_256_minus_prime () = ()
val lemma_pow2_260_mod_prime: unit -> Lemma (pow2 260 % S.prime = 0x1000003D10)
let lemma_pow2_260_mod_prime () =
calc (==) {
pow2 260 % S.prime;
(==) { Math.Lemmas.pow2_plus 256 4 }
pow2 256 * pow2 4 % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_l (pow2 256) (pow2 4) S.prime }
(pow2 256 % S.prime) * pow2 4 % S.prime;
(==) { lemma_prime () }
0x1000003D1 * pow2 4 % S.prime;
(==) { assert_norm (0x1000003D1 * pow2 4 = 0x1000003D10) }
0x1000003D10 % S.prime;
(==) { Math.Lemmas.small_mod 0x1000003D10 S.prime }
0x1000003D10;
}
val lemma_as_nat_bound_f4_lt_powa: f:felem5 -> a:nat -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 a))
(ensures as_nat5 f <= pow2 (208 + a) - 1)
let lemma_as_nat_bound_f4_lt_powa f a =
let (f0,f1,f2,f3,f4) = f in
calc (<=) { //as_nat5 f ==
v f0 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) { }
pow2 52 - 1 + v f1 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208;
(<=) {
Math.Lemmas.lemma_mult_le_right pow52 (v f1) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow52 }
pow2 52 * pow52 + v f2 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow104 (v f2) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow104;
Math.Lemmas.pow2_plus 52 52 }
pow2 52 * pow104 + v f3 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow156 (v f3) (pow2 52 - 1);
Math.Lemmas.distributivity_sub_left (pow2 52) 1 pow156;
Math.Lemmas.pow2_plus 52 104 }
pow2 52 * pow156 + v f4 * pow208 - 1;
(<=) {
Math.Lemmas.lemma_mult_le_right pow208 (v f4) (pow2 a - 1);
Math.Lemmas.distributivity_sub_left (pow2 a) 1 pow208;
Math.Lemmas.pow2_plus 52 156;
Math.Lemmas.pow2_plus a 208 }
pow2 (208 + a) - 1;
}
val lemma_as_nat_bound: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures as_nat5 f < pow2 256)
let lemma_as_nat_bound f =
lemma_as_nat_bound_f4_lt_powa f 48
val lemma_as_nat_bound_f4_lt_pow12: f:felem5 -> Lemma
(requires (let (f0,f1,f2,f3,f4) = f in
felem_fits5 f (1,1,1,1,1) /\ v f4 < pow2 12))
(ensures as_nat5 f <= pow2 220 - 1)
let lemma_as_nat_bound_f4_lt_pow12 f =
lemma_as_nat_bound_f4_lt_powa f 12
val lemma_as_nat_decompose: f:felem5 -> Lemma
(requires felem_fits5 f (1,1,1,1,1))
(ensures (let (f0,f1,f2,f3,f4) = f in
v f4 = as_nat5 f / pow208 /\
v f3 = as_nat5 f % pow208 / pow156 /\
v f2 = as_nat5 f % pow156 / pow104 /\
v f1 = as_nat5 f % pow104 / pow52 /\
v f0 = as_nat5 f % pow52))
let lemma_as_nat_decompose f =
let (f0,f1,f2,f3,f4) = f in
lemma_as_nat_bound f;
Math.Lemmas.euclidean_division_definition (as_nat5 f) pow208;
assert (v f4 = as_nat5 f / pow208);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow208) pow156;
assert (v f3 = as_nat5 f % pow208 / pow156);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 156 208;
assert (as_nat5 f % pow208 % pow156 == as_nat5 f % pow156);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow156) pow104;
assert (v f2 = as_nat5 f % pow156 / pow104);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 104 156;
assert (as_nat5 f % pow156 % pow104 == as_nat5 f % pow104);
Math.Lemmas.euclidean_division_definition (as_nat5 f % pow104) pow52;
assert (v f1 = as_nat5 f % pow104 / pow52);
Math.Lemmas.pow2_modulo_modulo_lemma_1 (as_nat5 f) 52 104;
assert (as_nat5 f % pow104 % pow52 == as_nat5 f % pow52);
assert (v f0 = as_nat5 f % pow52)
#push-options "--ifuel 1"
val as_nat_inj (f1 f2: felem5) : Lemma
(requires
felem_fits5 f1 (1,1,1,1,1) /\ felem_fits5 f2 (1,1,1,1,1) /\
as_nat5 f1 == as_nat5 f2)
(ensures
(let (a0,a1,a2,a3,a4) = f1 in let (b0,b1,b2,b3,b4) = f2 in
a0 == b0 /\ a1 == b1 /\ a2 == b2 /\ a3 == b3 /\ a4 == b4))
let as_nat_inj f1 f2 =
lemma_as_nat_decompose f1;
lemma_as_nat_decompose f2
#pop-options
val lemma_normalize_x_le_1: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 <= 1)
let lemma_normalize_x_le_1 t4 =
calc (==) {
(2 * (pow2 48 - 1)) / pow2 48;
(==) { Math.Lemmas.distributivity_add_right 2 (pow2 48) 1 }
(2 * pow2 48 - 2) / pow2 48;
(==) { Math.Lemmas.division_addition_lemma (-2) (pow2 48) 2 }
(-2) / pow2 48 + 2;
(==) { assert_norm ((-2) / pow2 48 = -1) }
1;
};
assert (v t4 <= 2 * (pow2 48 - 1));
Math.Lemmas.lemma_div_le (v t4) (2 * pow2 48 - 2) (pow2 48);
assert (v t4 / pow2 48 <= 1)
val lemma_div_pow48: t4:uint64 -> Lemma
(requires felem_fits_last1 t4 2)
(ensures v t4 / pow2 48 == (if v t4 < pow2 48 then 0 else 1))
let lemma_div_pow48 t4 =
if v t4 < pow2 48 then
Math.Lemmas.small_div (v t4) (pow2 48)
else begin
lemma_normalize_x_le_1 t4;
assert (v t4 / pow2 48 <= 1);
Math.Lemmas.lemma_div_le (pow2 48) (v t4) (pow2 48);
assert (1 <= v t4 / pow2 48) end
val lemma_mask52: a:uint64 ->
Lemma (let r = a &. mask52 in
v r = v a % pow2 52 /\ felem_fits1 r 1)
let lemma_mask52 a =
let r = a &. mask52 in
assert_norm (v mask52 = pow2 52 - 1);
mod_mask_lemma a 52ul;
assert (v (mod_mask #U64 #SEC 52ul) == v mask52);
assert (v r = v a % pow2 52);
assert (felem_fits1 r 1)
val lemma_mask48: a:uint64 ->
Lemma (let r = a &. mask48 in
v r = v a % pow2 48 /\ felem_fits_last1 r 1)
let lemma_mask48 a =
let r = a &. mask48 in
assert_norm (v mask48 = pow2 48 - 1);
mod_mask_lemma a 48ul;
assert (v (mod_mask #U64 #SEC 48ul) == v mask48);
assert (v r = v a % pow2 48);
assert (felem_fits_last1 r 1)
val lemma_add_rsh52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52 m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max52 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 52 12 }
m1 * max52 + max52;
(==) { Math.Lemmas.distributivity_add_left m1 1 max52 }
(m1 + 1) * max52;
};
Math.Lemmas.lemma_mult_le_right max52 (m1 + 1) 4096;
assert_norm (4096 * max52 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits1 c (m1 + 1))
val lemma_add_rsh52_last: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures (let c = a +. (b >>. 52ul) in
felem_fits_last1 c (m1 + 1) /\ v c = v a + v b / pow2 52))
let lemma_add_rsh52_last m1 m2 a b =
let c = a +. (b >>. 52ul) in
calc (<) {
v a + v b / pow2 52;
(<) { Math.Lemmas.lemma_div_lt (v b) 64 52 }
m1 * max48 + pow2 12;
(<=) { Math.Lemmas.pow2_lt_compat 48 12 }
m1 * max48 + max48;
(==) { Math.Lemmas.distributivity_add_left m1 1 max48 }
(m1 + 1) * max48;
};
Math.Lemmas.lemma_mult_le_right max48 (m1 + 1) 65536;
assert_norm (65536 * max48 < pow2 64);
Math.Lemmas.small_mod (v a + v b / pow2 52) (pow2 64);
assert (v c = v a + v b / pow2 52);
assert (felem_fits_last1 c (m1 + 1))
val lemma_carry52: m1:scale64 -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 4096)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52 m1 m2 a b
val lemma_carry_last52: m1:scale64_last -> m2:scale64 -> a:uint64 -> b:uint64 -> Lemma
(requires felem_fits_last1 a m1 /\ felem_fits1 b m2 /\ m1 + 1 <= 65536)
(ensures
(let c = a +. (b >>. 52ul) in let d = b &. mask52 in
felem_fits1 d 1 /\ felem_fits_last1 c (m1 + 1) /\
v d = v b % pow2 52 /\ v c = v a + v b / pow2 52))
let lemma_carry_last52 m1 m2 a b =
lemma_mask52 b;
lemma_add_rsh52_last m1 m2 a b
val lemma_small_sub_mod: a:nat -> n:pos -> Lemma
(requires n <= a /\ a < 2 * n)
(ensures a % n = a - n)
let lemma_small_sub_mod a n =
calc (==) {
a % n;
(==) { Math.Lemmas.sub_div_mod_1 a n }
(a - n) % n;
(==) { Math.Lemmas.small_mod (a - n) n }
a - n;
}
val carry_last_small_mod_lemma: t4:uint64 -> t3':uint64 -> Lemma
(requires felem_fits_last1 t4 1 /\
v (t4 +. (t3' >>. 52ul)) == v t4 + v t3' / pow2 52)
(ensures (let r = t4 +. (t3' >>. 52ul) in
felem_fits_last1 r 2 /\
v r < v t4 + pow2 12 /\ (v r >= pow2 48 ==> v r % pow2 48 < pow2 12)))
let carry_last_small_mod_lemma t4 t3' =
let r = t4 +. (t3' >>. 52ul) in
assert (v r = v t4 + v t3' / pow2 52);
Math.Lemmas.lemma_div_lt (v t3') 64 52;
assert (v r < v t4 + pow2 12);
Math.Lemmas.pow2_lt_compat 48 12;
assert (felem_fits_last1 r 2);
if v r >= pow2 48 then begin
lemma_small_sub_mod (v r) (pow2 48);
assert (v r % pow2 48 = v r - pow2 48);
assert (v r % pow2 48 < pow2 12) end
val lemma_a_plus_b_mul_pow256 (a b:int) :
Lemma ((a + b * pow2 256) % S.prime == (a + b * 0x1000003D1) % S.prime)
let lemma_a_plus_b_mul_pow256 a b =
calc (==) {
(a + b * pow2 256) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * pow2 256) S.prime }
(a + b * pow2 256 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_mul_distr_r b (pow2 256) S.prime }
(a + b * (pow2 256 % S.prime) % S.prime) % S.prime;
(==) { lemma_prime () }
(a + b * 0x1000003D1 % S.prime) % S.prime;
(==) { Math.Lemmas.lemma_mod_plus_distr_r a (b * 0x1000003D1) S.prime }
(a + b * 0x1000003D1) % S.prime;
}
val as_nat_mod_prime (t0 t1 t2 t3 t4:int) : Lemma
((t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime =
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 + t4 / pow2 48 * 0x1000003D1) % S.prime) | {
"checked_file": "/",
"dependencies": [
"Spec.K256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.K256.MathLemmas.fst.checked",
"Hacl.Spec.K256.Field52.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.K256.Field52.Definitions.Lemmas.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.K256.MathLemmas",
"short_module": "ML"
},
{
"abbrev": true,
"full_module": "Spec.K256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"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": "Hacl.Spec.K256.Field52.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.K256.Field52.Definitions",
"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 | t0: Prims.int -> t1: Prims.int -> t2: Prims.int -> t3: Prims.int -> t4: Prims.int
-> FStar.Pervasives.Lemma
(ensures
(t0 + t1 * Hacl.Spec.K256.Field52.Definitions.pow52 +
t2 * Hacl.Spec.K256.Field52.Definitions.pow104 +
t3 * Hacl.Spec.K256.Field52.Definitions.pow156 +
t4 * Hacl.Spec.K256.Field52.Definitions.pow208) %
Spec.K256.PointOps.prime =
(t0 + t1 * Hacl.Spec.K256.Field52.Definitions.pow52 +
t2 * Hacl.Spec.K256.Field52.Definitions.pow104 +
t3 * Hacl.Spec.K256.Field52.Definitions.pow156 +
(t4 % Prims.pow2 48) * Hacl.Spec.K256.Field52.Definitions.pow208 +
(t4 / Prims.pow2 48) * 0x1000003D1) %
Spec.K256.PointOps.prime) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.int",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Hacl.Spec.K256.Field52.Definitions.pow52",
"Hacl.Spec.K256.Field52.Definitions.pow104",
"Hacl.Spec.K256.Field52.Definitions.pow156",
"Hacl.Spec.K256.Field52.Definitions.pow208",
"Spec.K256.PointOps.prime",
"Prims.pow2",
"Prims.op_Division",
"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.distributivity_add_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.K256.Field52.Definitions.Lemmas.lemma_a_plus_b_mul_pow256"
] | [] | false | false | true | false | false | let as_nat_mod_prime t0 t1 t2 t3 t4 =
| calc ( == ) {
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + t4 * pow208) % S.prime;
( == ) { Math.Lemmas.euclidean_division_definition t4 (pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + ((t4 / pow2 48) * pow2 48 + t4 % pow2 48) * pow208) %
S.prime;
( == ) { Math.Lemmas.distributivity_add_left ((t4 / pow2 48) * pow2 48) (t4 % pow2 48) pow208 }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + ((t4 / pow2 48) * pow2 48) * pow208 +
(t4 % pow2 48) * pow208) %
S.prime;
( == ) { (Math.Lemmas.paren_mul_right (t4 / pow2 48) (pow2 48) pow208;
Math.Lemmas.pow2_plus 48 208) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 / pow2 48) * pow2 256 + (t4 % pow2 48) * pow208
) %
S.prime;
( == ) { lemma_a_plus_b_mul_pow256 (t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 +
(t4 % pow2 48) * pow208)
(t4 / pow2 48) }
(t0 + t1 * pow52 + t2 * pow104 + t3 * pow156 + (t4 % pow2 48) * pow208 +
(t4 / pow2 48) * 0x1000003D1) %
S.prime;
} | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_le_is_uints_from_bytes_le | val bn_from_bytes_le_is_uints_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (bn_from_bytes_le #t len b == uints_from_bytes_le b) | val bn_from_bytes_le_is_uints_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (bn_from_bytes_le #t len b == uints_from_bytes_le b) | let bn_from_bytes_le_is_uints_from_bytes_le #t len b =
let lp = bn_from_bytes_le #t len b in
let rp = uints_from_bytes_le #t #SEC #(len / numbytes t) b in
//uints_from_bytes_le_nat_lemma #t #SEC #(len / numbytes t) b;
//assert (nat_from_intseq_le rp == nat_from_bytes_le b);
//bn_from_bytes_le_lemma #t len b;
//assert (bn_v lp == nat_from_bytes_le b);
//assert (nat_from_intseq_le rp == bn_v lp);
assert (bn_v rp == bn_v lp);
bn_eval_inj (len / numbytes t) rp lp | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 478,
"start_col": 0,
"start_line": 468
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0)
let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b))
let nat_from_bytes_le_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i:nat). i < len - len0 ==> r.[len0 + i] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r == nat_from_intseq_le (slice r 0 len0) + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r == nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len)
val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b)
let bn_from_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
let res = uints_from_bytes_le #t #SEC #bnLen tmp in
uints_from_bytes_le_nat_lemma #t #SEC #bnLen tmp;
bn_v_is_nat_from_intseq_le_lemma bnLen res;
nat_from_bytes_le_eq_lemma len tmpLen b
val bn_to_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_le len b == nat_to_intseq_le #U8 len (bn_v b))
let bn_to_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
let res = sub tmp 0 len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
uints_to_bytes_le_nat_lemma #t #SEC bnLen (bn_v b);
bn_v_is_nat_from_intseq_le_lemma bnLen b;
lemma_nat_from_to_intseq_le_preserves_value bnLen b;
assert (uints_to_bytes_le #t #SEC #bnLen b == nat_to_intseq_le #U8 tmpLen (bn_v b));
let aux (i:nat{i < len}) :
Lemma (index #uint8 #tmpLen (nat_to_intseq_le #U8 tmpLen (bn_v b)) i ==
index #uint8 #len (nat_to_intseq_le #U8 len (bn_v b)) i) =
index_nat_to_intseq_le #U8 #SEC tmpLen (bn_v b) i;
index_nat_to_intseq_le #U8 #SEC len (bn_v b) i in
Classical.forall_intro aux;
eq_intro (nat_to_intseq_le #U8 #SEC len (bn_v b)) res
val bn_from_bytes_le_is_uints_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (bn_from_bytes_le #t len b == uints_from_bytes_le b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t /\ len % Lib.IntTypes.numbytes t = 0 } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.bn_from_bytes_le len b == Lib.ByteSequence.uints_from_bytes_le b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Definitions.bn_eval_inj",
"Prims.op_Division",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.uints_from_bytes_le",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_le"
] | [] | true | false | true | false | false | let bn_from_bytes_le_is_uints_from_bytes_le #t len b =
| let lp = bn_from_bytes_le #t len b in
let rp = uints_from_bytes_le #t #SEC #(len / numbytes t) b in
assert (bn_v rp == bn_v lp);
bn_eval_inj (len / numbytes t) rp lp | false |
Print.fst | Print.just_print | val just_print (s: string) : Tac unit | val just_print (s: string) : Tac unit | let just_print (s: string): Tac unit =
dump s | {
"file_name": "examples/native_tactics/Print.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 22,
"start_col": 0,
"start_line": 21
} | (*
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 Print
open FStar.Tactics.V2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Print.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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: Prims.string -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.string",
"FStar.Stubs.Tactics.V2.Builtins.dump",
"Prims.unit"
] | [] | false | true | false | false | false | let just_print (s: string) : Tac unit =
| dump s | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_from_bytes_be_is_uints_from_bytes_be | val bn_from_bytes_be_is_uints_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (reverse (bn_from_bytes_be #t len b) == uints_from_bytes_be b) | val bn_from_bytes_be_is_uints_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (reverse (bn_from_bytes_be #t len b) == uints_from_bytes_be b) | let bn_from_bytes_be_is_uints_from_bytes_be #t len b =
let lp = bn_from_bytes_be #t len b in
let rp = uints_from_bytes_be #t #SEC #(len / numbytes t) b in
uints_from_bytes_be_nat_lemma #t #SEC #(len / numbytes t) b;
assert (nat_from_intseq_be rp == nat_from_bytes_be b);
bn_from_bytes_be_lemma #t len b;
assert (bn_v lp == nat_from_bytes_be b);
bn_v_is_nat_from_intseq_be_lemma (len / numbytes t) lp;
assert (bn_v lp == nat_from_intseq_be (reverse lp));
assert (nat_from_intseq_be rp == nat_from_intseq_be (reverse lp));
nat_from_intseq_be_inj rp (reverse lp) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 499,
"start_col": 0,
"start_line": 487
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0)
let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b))
let nat_from_bytes_le_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i:nat). i < len - len0 ==> r.[len0 + i] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r == nat_from_intseq_le (slice r 0 len0) + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r == nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len)
val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b)
let bn_from_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
let res = uints_from_bytes_le #t #SEC #bnLen tmp in
uints_from_bytes_le_nat_lemma #t #SEC #bnLen tmp;
bn_v_is_nat_from_intseq_le_lemma bnLen res;
nat_from_bytes_le_eq_lemma len tmpLen b
val bn_to_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_le len b == nat_to_intseq_le #U8 len (bn_v b))
let bn_to_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
let res = sub tmp 0 len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
uints_to_bytes_le_nat_lemma #t #SEC bnLen (bn_v b);
bn_v_is_nat_from_intseq_le_lemma bnLen b;
lemma_nat_from_to_intseq_le_preserves_value bnLen b;
assert (uints_to_bytes_le #t #SEC #bnLen b == nat_to_intseq_le #U8 tmpLen (bn_v b));
let aux (i:nat{i < len}) :
Lemma (index #uint8 #tmpLen (nat_to_intseq_le #U8 tmpLen (bn_v b)) i ==
index #uint8 #len (nat_to_intseq_le #U8 len (bn_v b)) i) =
index_nat_to_intseq_le #U8 #SEC tmpLen (bn_v b) i;
index_nat_to_intseq_le #U8 #SEC len (bn_v b) i in
Classical.forall_intro aux;
eq_intro (nat_to_intseq_le #U8 #SEC len (bn_v b)) res
val bn_from_bytes_le_is_uints_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (bn_from_bytes_le #t len b == uints_from_bytes_le b)
let bn_from_bytes_le_is_uints_from_bytes_le #t len b =
let lp = bn_from_bytes_le #t len b in
let rp = uints_from_bytes_le #t #SEC #(len / numbytes t) b in
//uints_from_bytes_le_nat_lemma #t #SEC #(len / numbytes t) b;
//assert (nat_from_intseq_le rp == nat_from_bytes_le b);
//bn_from_bytes_le_lemma #t len b;
//assert (bn_v lp == nat_from_bytes_le b);
//assert (nat_from_intseq_le rp == bn_v lp);
assert (bn_v rp == bn_v lp);
bn_eval_inj (len / numbytes t) rp lp
val bn_from_bytes_be_is_uints_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t /\ len % numbytes t = 0}
-> b:lseq uint8 len ->
Lemma (reverse (bn_from_bytes_be #t len b) == uints_from_bytes_be b) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t /\ len % Lib.IntTypes.numbytes t = 0 } ->
b: Lib.Sequence.lseq Lib.IntTypes.uint8 len
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.reverse (Hacl.Spec.Bignum.Convert.bn_from_bytes_be len b) ==
Lib.ByteSequence.uints_from_bytes_be b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Lib.ByteSequence.nat_from_intseq_be_inj",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Convert.reverse",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.bits",
"Lib.ByteSequence.nat_from_intseq_be",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_be_lemma",
"Prims.op_Division",
"Lib.ByteSequence.nat_from_bytes_be",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be_lemma",
"Lib.IntTypes.U8",
"Lib.ByteSequence.uints_from_bytes_be_nat_lemma",
"Lib.IntTypes.int_t",
"Lib.ByteSequence.uints_from_bytes_be",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Convert.bn_from_bytes_be"
] | [] | true | false | true | false | false | let bn_from_bytes_be_is_uints_from_bytes_be #t len b =
| let lp = bn_from_bytes_be #t len b in
let rp = uints_from_bytes_be #t #SEC #(len / numbytes t) b in
uints_from_bytes_be_nat_lemma #t #SEC #(len / numbytes t) b;
assert (nat_from_intseq_be rp == nat_from_bytes_be b);
bn_from_bytes_be_lemma #t len b;
assert (bn_v lp == nat_from_bytes_be b);
bn_v_is_nat_from_intseq_be_lemma (len / numbytes t) lp;
assert (bn_v lp == nat_from_intseq_be (reverse lp));
assert (nat_from_intseq_be rp == nat_from_intseq_be (reverse lp));
nat_from_intseq_be_inj rp (reverse lp) | false |
Hacl.Impl.Ed25519.Field51.fst | Hacl.Impl.Ed25519.Field51.linv | val linv (a: LSeq.lseq uint64 20) : Type0 | val linv (a: LSeq.lseq uint64 20) : Type0 | let linv (a:LSeq.lseq uint64 20) : Type0 =
let open Hacl.Spec.Curve25519.Field51 in
mul_inv_t (lseq_as_felem (LSeq.sub a 0 5)) /\
mul_inv_t (lseq_as_felem (LSeq.sub a 5 5)) /\
mul_inv_t (lseq_as_felem (LSeq.sub a 10 5)) /\
mul_inv_t (lseq_as_felem (LSeq.sub a 15 5)) /\
inv_ext_point a | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Field51.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 17,
"end_line": 75,
"start_col": 0,
"start_line": 69
} | module Hacl.Impl.Ed25519.Field51
open FStar.HyperStack
open Lib.IntTypes
open Lib.Buffer
open FStar.Mul
module LSeq = Lib.Sequence
module P = Hacl.Impl.Curve25519.Field51
module S = Spec.Curve25519
let felem = lbuffer uint64 5ul
let point = lbuffer uint64 20ul
let as_nat (h:mem) (f:felem) : GTot nat = P.as_nat h f
let fevalh (h:mem) (f:felem) : GTot S.elem = P.fevalh h f
noextract
val point_eval:h:mem -> p:point -> GTot Spec.Ed25519.ext_point
let point_eval h p =
let x = gsub p 0ul 5ul in
let y = gsub p 5ul 5ul in
let z = gsub p 10ul 5ul in
let t = gsub p 15ul 5ul in
(fevalh h x, fevalh h y, fevalh h z, fevalh h t)
noextract
val felem_fits: h:mem -> f:felem -> m:Hacl.Spec.Curve25519.Field51.Definition.scale64_5 -> Type0
let felem_fits h f m = P.felem_fits h f m
noextract
let as_felem (h:mem) (f:felem) =
P.as_felem h f
noextract
let mul_inv_t (h:mem) (f:felem) : GTot Type0 =
P.mul_inv_t h f
noextract
let point_inv_t (h:mem) (p:point) : GTot Type0 =
mul_inv_t h (gsub p 0ul 5ul) /\
mul_inv_t h (gsub p 5ul 5ul) /\
mul_inv_t h (gsub p 10ul 5ul) /\
mul_inv_t h (gsub p 15ul 5ul)
unfold
let lseq_as_felem (a:LSeq.lseq uint64 5) : Hacl.Spec.Curve25519.Field51.Definition.felem5 =
let open Lib.Sequence in
(a.[0], a.[1], a.[2], a.[3], a.[4])
unfold
let refl_ext_point (a:LSeq.lseq uint64 20) : GTot Spec.Ed25519.ext_point =
let open Hacl.Spec.Curve25519.Field51.Definition in
let x = feval (lseq_as_felem (LSeq.sub a 0 5)) in
let y = feval (lseq_as_felem (LSeq.sub a 5 5)) in
let z = feval (lseq_as_felem (LSeq.sub a 10 5)) in
let t = feval (lseq_as_felem (LSeq.sub a 15 5)) in
(x, y, z, t)
unfold
let inv_ext_point (a:LSeq.lseq uint64 20) : Type0 =
Spec.Ed25519.point_inv (refl_ext_point a) | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Spec.Curve25519.Field51.fst.checked",
"Hacl.Impl.Curve25519.Field51.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Field51.fst"
} | [
{
"abbrev": true,
"full_module": "Spec.Curve25519",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field51",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"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",
"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": 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": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | a: Lib.Sequence.lseq Lib.IntTypes.uint64 20 -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.l_and",
"Hacl.Spec.Curve25519.Field51.mul_inv_t",
"Hacl.Impl.Ed25519.Field51.lseq_as_felem",
"Lib.Sequence.sub",
"Hacl.Impl.Ed25519.Field51.inv_ext_point"
] | [] | false | false | false | false | true | let linv (a: LSeq.lseq uint64 20) : Type0 =
| let open Hacl.Spec.Curve25519.Field51 in
mul_inv_t (lseq_as_felem (LSeq.sub a 0 5)) /\ mul_inv_t (lseq_as_felem (LSeq.sub a 5 5)) /\
mul_inv_t (lseq_as_felem (LSeq.sub a 10 5)) /\ mul_inv_t (lseq_as_felem (LSeq.sub a 15 5)) /\
inv_ext_point a | false |
Lib.IntVector.Transpose.fst | Lib.IntVector.Transpose.transpose8x8_lseq_is_transposewxw | val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012) | val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012) | let transpose8x8_lseq_is_transposewxw #t vs0 =
let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012) | {
"file_name": "lib/Lib.IntVector.Transpose.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 67,
"end_line": 214,
"start_col": 0,
"start_line": 201
} | module Lib.IntVector.Transpose
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
///
/// transpose4x4
///
inline_for_extraction
val transpose4x4_0: #t:v_inttype -> vec_t4 t -> vec_t4 t
let transpose4x4_0 #t (v0,v1,v2,v3) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v0'' = vec_interleave_low_n 2 v0' v2' in
let v1'' = vec_interleave_high_n 2 v0' v2' in
let v2'' = vec_interleave_low_n 2 v1' v3' in
let v3'' = vec_interleave_high_n 2 v1' v3' in
(v0'',v2'',v1'',v3'')
inline_for_extraction
val transpose4x4_uint32: #t:v_inttype{t == U32} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint32 #t vs =
let (v0'',v2'',v1'',v3'') = transpose4x4_0 #t vs in
(v0'',v1'',v2'',v3'')
inline_for_extraction
val transpose4x4_uint64: #t:v_inttype{t == U64} -> vec_t4 t -> vec_t4 t
let transpose4x4_uint64 #t vs = transpose4x4_0 #t vs
let transpose4x4 #t vs =
match t with
| U32 -> transpose4x4_uint32 #t vs
| U64 -> transpose4x4_uint64 #t vs
///
/// transpose8x8
///
inline_for_extraction
val transpose8x8_0: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low v0 v1 in
let v1' = vec_interleave_high v0 v1 in
let v2' = vec_interleave_low v2 v3 in
let v3' = vec_interleave_high v2 v3 in
let v4' = vec_interleave_low v4 v5 in
let v5' = vec_interleave_high v4 v5 in
let v6' = vec_interleave_low v6 v7 in
let v7' = vec_interleave_high v6 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_1: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_1 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 2 v0 v2 in
let v2' = vec_interleave_high_n 2 v0 v2 in
let v1' = vec_interleave_low_n 2 v1 v3 in
let v3' = vec_interleave_high_n 2 v1 v3 in
let v4' = vec_interleave_low_n 2 v4 v6 in
let v6' = vec_interleave_high_n 2 v4 v6 in
let v5' = vec_interleave_low_n 2 v5 v7 in
let v7' = vec_interleave_high_n 2 v5 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_2: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_2 #t (v0,v1,v2,v3,v4,v5,v6,v7) =
let v0' = vec_interleave_low_n 4 v0 v4 in
let v4' = vec_interleave_high_n 4 v0 v4 in
let v1' = vec_interleave_low_n 4 v1 v5 in
let v5' = vec_interleave_high_n 4 v1 v5 in
let v2' = vec_interleave_low_n 4 v2 v6 in
let v6' = vec_interleave_high_n 4 v2 v6 in
let v3' = vec_interleave_low_n 4 v3 v7 in
let v7' = vec_interleave_high_n 4 v3 v7 in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_012: #t:v_inttype -> vec_t8 t -> vec_t8 t
let transpose8x8_012 #t vs0 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = vs0 in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_0 #t (v0,v1,v2,v3,v4,v5,v6,v7) in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_1 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_2 #t (v0',v1',v2',v3',v4',v5',v6',v7') in
(v0',v1',v2',v3',v4',v5',v6',v7')
inline_for_extraction
val transpose8x8_uint32: #t:v_inttype{t == U32} -> vec_t8 t -> vec_t8 t
let transpose8x8_uint32 #t vs0 =
let (v0',v1',v2',v3',v4',v5',v6',v7') = transpose8x8_012 #t vs0 in
(v0',v2',v1',v3',v4',v6',v5',v7')
let transpose8x8 #t vs =
match t with
| U32 -> transpose8x8_uint32 #t vs
///
/// generic transpose
///
val lemma_l_plus_pow2i_lt: #w:pos -> n:nat{pow2 n == w} -> i:nat{i < n} -> l:nat{l < w} -> Lemma
(requires l % (2 * pow2 i) < pow2 i)
(ensures l + pow2 i < w)
let lemma_l_plus_pow2i_lt #w n i l =
let pow2i1 = pow2 (i + 1) in
calc (<) {
l + pow2 i;
(==) { Math.Lemmas.euclidean_division_definition l pow2i1 }
l / pow2i1 * pow2i1 + l % pow2i1 + pow2 i;
(==) { Math.Lemmas.pow2_plus 1 i }
l / pow2i1 * pow2i1 + l % (2 * pow2 i) + pow2 i;
(<) { assert (l % (2 * pow2 i) < pow2 i) }
l / pow2i1 * pow2i1 + pow2 i + pow2 i;
(==) { Math.Lemmas.pow2_double_sum i }
l / pow2i1 * pow2i1 + pow2i1;
(==) { Math.Lemmas.distributivity_add_left (l / pow2i1) 1 pow2i1 }
(l / pow2i1 + 1) * pow2i1;
(<=) { Math.Lemmas.lemma_div_lt_nat l n (i + 1) }
pow2 (n - i - 1) * pow2 (i + 1);
(==) { Math.Lemmas.pow2_plus (n - i - 1) (i + 1) }
pow2 n;
}
inline_for_extraction
val transposewxw_f_l:
#w:width
-> #t:v_inttype
-> n:nat{pow2 n == w}
-> i:nat{i < n}
-> lseq (vec_t t w) w
-> l:nat{l < w} ->
vec_t t w
let transposewxw_f_l #w #t n i vs l =
Math.Lemmas.pow2_multiplication_modulo_lemma_1 1 i n;
if l % (2 * pow2 i) < pow2 i
then begin
lemma_l_plus_pow2i_lt #w n i l;
vec_interleave_low_n (pow2 i) vs.[l] vs.[l + pow2 i] end
else
vec_interleave_high_n (pow2 i) vs.[l - pow2 i] vs.[l]
inline_for_extraction
val transposewxw_f: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> i:nat{i < n} -> lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_f #w #t n i vs =
createi w (transposewxw_f_l #w n i vs)
val transposewxw_lseq: #w:width -> #t:v_inttype -> n:nat{pow2 n == w} -> vs:lseq (vec_t t w) w -> lseq (vec_t t w) w
let transposewxw_lseq #w #t n vs =
Loops.repeati n (transposewxw_f #w n) vs
///
/// transposewxw_lseq lemmas
///
inline_for_extraction
let f_lseq4 (#t:v_inttype) (vs:lseq (vec_t t 4) 4) (f:vec_t4 t -> vec_t4 t) : lseq (vec_t t 4) 4 =
let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in
let (r0,r1,r2,r3) = f (v0,v1,v2,v3) in
create4 r0 r1 r2 r3
val transpose4x4_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 4) 4 ->
Lemma (transposewxw_lseq 2 vs `Seq.equal` f_lseq4 vs transpose4x4_0)
let transpose4x4_lseq_is_transposewxw #t vs0 =
let n = 2 in
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #4 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #4 n) vs0;
eq_intro (transposewxw_lseq 2 vs0) (f_lseq4 vs0 transpose4x4_0)
inline_for_extraction
let f_lseq8 (#t:v_inttype) (vs:lseq (vec_t t 8) 8) (f:vec_t8 t -> vec_t8 t) : lseq (vec_t t 8) 8 =
let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in
let (r0,r1,r2,r3,r4,r5,r6,r7) = f (v0,v1,v2,v3,v4,v5,v6,v7) in
create8 r0 r1 r2 r3 r4 r5 r6 r7
val transpose8x8_lseq_is_transposewxw: #t:v_inttype -> vs:lseq (vec_t t 8) 8 ->
Lemma (transposewxw_lseq 3 vs `Seq.equal` f_lseq8 vs transpose8x8_012) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Lib.IntVector.Transpose.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Lib.IntVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntVector",
"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 | vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (Lib.IntVector.Transpose.transposewxw_lseq 3 vs)
(Lib.IntVector.Transpose.f_lseq8 vs Lib.IntVector.Transpose.transpose8x8_012)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.IntVector.v_inttype",
"Lib.Sequence.lseq",
"Lib.IntVector.vec_t",
"Lib.Sequence.eq_intro",
"Lib.IntVector.Transpose.transposewxw_lseq",
"Lib.IntVector.Transpose.f_lseq8",
"Lib.IntVector.Transpose.transpose8x8_012",
"Prims.unit",
"Lib.IntVector.Transpose.transpose8x8_2",
"Lib.IntVector.Transpose.transposewxw_f",
"Lib.IntVector.Transpose.transpose8x8_1",
"Lib.IntVector.Transpose.transpose8x8_0",
"Lib.LoopCombinators.eq_repeati0",
"Lib.LoopCombinators.unfold_repeati",
"Prims.int"
] | [] | true | false | true | false | false | let transpose8x8_lseq_is_transposewxw #t vs0 =
| let n = 3 in
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 2;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 1;
Loops.unfold_repeati n (transposewxw_f #8 n) vs0 0;
Loops.eq_repeati0 n (transposewxw_f #8 n) vs0;
let res0 = transposewxw_f n 0 vs0 in
eq_intro res0 (f_lseq8 vs0 transpose8x8_0);
let res1 = transposewxw_f n 1 res0 in
eq_intro res1 (f_lseq8 res0 transpose8x8_1);
let res2 = transposewxw_f n 2 res1 in
eq_intro res2 (f_lseq8 res1 transpose8x8_2);
eq_intro (transposewxw_lseq 3 vs0) (f_lseq8 vs0 transpose8x8_012) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be_lemma_ | val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b)) | val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b)) | let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b)) | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 330,
"start_col": 0,
"start_line": 315
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_pos{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t len
{Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 (Lib.IntTypes.bits t * len)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.bn_to_bytes_be_ len b ==
Lib.ByteSequence.nat_to_intseq_be (Lib.IntTypes.numbytes t * len)
(Hacl.Spec.Bignum.Definitions.bn_v b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.bits",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint8",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_",
"Lib.ByteSequence.nat_to_intseq_be",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.index",
"Prims.op_Multiply",
"Prims.l_True",
"Prims.squash",
"Lib.IntTypes.int_t",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_lemma_aux",
"Prims._assert",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_Modulus",
"Prims.op_Division",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"Lib.IntTypes.uint",
"Hacl.Spec.Bignum.Convert.index_bn_to_bytes_be_",
"Lib.ByteSequence.index_nat_to_intseq_be",
"Lib.Sequence.seq",
"Prims.l_and",
"Lib.Sequence.length",
"Lib.ByteSequence.nat_from_intseq_be"
] | [] | false | false | true | false | false | let bn_to_bytes_be_lemma_ #t len b =
| let numb = numbytes t in
let lemma_aux (i: nat{i < numb * len})
: Lemma
((bn_to_bytes_be_ #t len b).[ i ] ==
index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i ==
uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[ i ] ==
uint #U8 #SEC (v b.[ len - i / numb - 1 ] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
()
in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b)) | false |
Rename.fst | Rename.l1 | val l1 : x: Prims.bool -> y: Prims.int -> z: Prims.unit -> Prims.unit | let l1 (x : bool) (y : int) (z : unit) =
assert (phi ==> (psi ==> xi)) by tau () | {
"file_name": "examples/native_tactics/Rename.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 43,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or 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 Rename
(* Testing the new printing based on the static environment *)
open FStar.Tactics.V2
assume val phi : Type
assume val psi : Type
assume val xi : Type
assume val p : squash xi
[@@plugin]
let tau =
fun () ->
let h0 = implies_intro () in
let h1 = implies_intro () in
dump "Test";
exact (`p) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Rename.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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 | x: Prims.bool -> y: Prims.int -> z: Prims.unit -> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.int",
"Prims.unit",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.l_imp",
"Rename.phi",
"Rename.psi",
"Rename.xi",
"Rename.tau"
] | [] | false | false | false | true | false | let l1 (x: bool) (y: int) (z: unit) =
| FStar.Tactics.Effect.assert_by_tactic (phi ==> (psi ==> xi))
(fun _ ->
();
tau ()) | false |
|
Rename.fst | Rename.tau | val tau : _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | let tau =
fun () ->
let h0 = implies_intro () in
let h1 = implies_intro () in
dump "Test";
exact (`p) | {
"file_name": "examples/native_tactics/Rename.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 14,
"end_line": 34,
"start_col": 0,
"start_line": 29
} | (*
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 Rename
(* Testing the new printing based on the static environment *)
open FStar.Tactics.V2
assume val phi : Type
assume val psi : Type
assume val xi : Type
assume val p : squash xi | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.V2.fst.checked",
"FStar.Tactics.Effect.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Rename.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics.V2",
"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 | _: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.unit",
"FStar.Tactics.V2.Derived.exact",
"FStar.Stubs.Tactics.V2.Builtins.dump",
"FStar.Tactics.NamedView.binding",
"FStar.Tactics.V2.Logic.implies_intro"
] | [] | false | true | false | false | false | let tau =
| fun () ->
let h0 = implies_intro () in
let h1 = implies_intro () in
dump "Test";
exact (`p) | false |
|
Pulse.Common.fst | Pulse.Common.assertby | val assertby (p: prop) (pf: (unit -> Lemma p)) : Lemma p | val assertby (p: prop) (pf: (unit -> Lemma p)) : Lemma p | let assertby (p:prop) (pf : unit -> Lemma p) : Lemma p =
pf () | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 7,
"end_line": 149,
"start_col": 0,
"start_line": 148
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys))
let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1)
let rec lemma_map_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> b) (xs : list a{xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs))
[SMTPat (map_dec top xs f)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_dec_len top f xs
let rec __lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}-> 'b)) (xs : list 'a{xs << top}) (ys : list 'b) (i:nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f)
(ensures f (xs `L.index` i) == ys `L.index` i)
= match xs, ys, i with
| _, _, 0 -> ()
| x::xs, y::ys, _ ->
__lemma_map_dec_index top f xs ys (i-1)
let lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}) -> 'b) (xs : list 'a{xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == map_dec top xs f `L.index` i)
= Classical.forall_intro (Classical.move_requires (__lemma_map_dec_index top f xs (map_dec top xs f)))
let lemma_map_dec_index_i (top:'z) (f : (x:'a{x<<top}) -> 'b) (xs : list 'a{xs << top}) (i : nat {i < L.length xs})
: Lemma (ensures f (xs `L.index` i) == map_dec top xs f `L.index` i)
= lemma_map_dec_index top f xs | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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: Prims.prop -> pf: (_: Prims.unit -> FStar.Pervasives.Lemma (ensures p))
-> FStar.Pervasives.Lemma (ensures p) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.prop",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let assertby (p: prop) (pf: (unit -> Lemma p)) : Lemma p =
| pf () | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_le_lemma | val bn_to_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_le len b == nat_to_intseq_le #U8 len (bn_v b)) | val bn_to_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_le len b == nat_to_intseq_le #U8 len (bn_v b)) | let bn_to_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
let res = sub tmp 0 len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
uints_to_bytes_le_nat_lemma #t #SEC bnLen (bn_v b);
bn_v_is_nat_from_intseq_le_lemma bnLen b;
lemma_nat_from_to_intseq_le_preserves_value bnLen b;
assert (uints_to_bytes_le #t #SEC #bnLen b == nat_to_intseq_le #U8 tmpLen (bn_v b));
let aux (i:nat{i < len}) :
Lemma (index #uint8 #tmpLen (nat_to_intseq_le #U8 tmpLen (bn_v b)) i ==
index #uint8 #len (nat_to_intseq_le #U8 len (bn_v b)) i) =
index_nat_to_intseq_le #U8 #SEC tmpLen (bn_v b) i;
index_nat_to_intseq_le #U8 #SEC len (bn_v b) i in
Classical.forall_intro aux;
eq_intro (nat_to_intseq_le #U8 #SEC len (bn_v b)) res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 459,
"start_col": 0,
"start_line": 438
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b))
let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res
(* Little-endian *)
val bn_v_is_nat_from_intseq_le_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_le b)
let rec bn_v_is_nat_from_intseq_le_lemma #t len b =
if len = 0 then
bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_le_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_le b1);
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v b == nat_from_intseq_le b1 + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_le_slice_lemma b (len - 1);
nat_from_intseq_le_lemma0 (slice b (len - 1) len);
assert (nat_from_intseq_le b == nat_from_intseq_le b1 + pow2 ((len - 1) * bits t) * v b.[len - 1]) end
val lemma_nat_from_bytes_le_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_le b == 0)
let rec lemma_nat_from_bytes_le_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_le_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_le_lemma0 (slice b 0 1);
lemma_nat_from_bytes_le_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_le_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 -> Lemma
(let tmp = create len (u8 0) in
nat_from_intseq_le b == nat_from_intseq_le (update_sub tmp 0 len0 b))
let nat_from_bytes_le_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp 0 len0 b in
assert (slice r 0 len0 == b);
assert (forall (i:nat). i < len - len0 ==> r.[len0 + i] == u8 0);
nat_from_intseq_le_slice_lemma #U8 #SEC #len r len0;
assert (nat_from_intseq_le r == nat_from_intseq_le (slice r 0 len0) + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
assert (nat_from_intseq_le r == nat_from_intseq_le b + pow2 (len0 * 8) * nat_from_intseq_le (Seq.slice r len0 len));
lemma_nat_from_bytes_le_zeroes (len - len0) (Seq.slice r len0 len)
val bn_from_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_le #t len b) == nat_from_bytes_le b)
let bn_from_bytes_le_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
let res = uints_from_bytes_le #t #SEC #bnLen tmp in
uints_from_bytes_le_nat_lemma #t #SEC #bnLen tmp;
bn_v_is_nat_from_intseq_le_lemma bnLen res;
nat_from_bytes_le_eq_lemma len tmpLen b
val bn_to_bytes_le_lemma:
#t:limb_t
-> len:size_pos{numbytes t * (blocks len (numbytes t)) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_le len b == nat_to_intseq_le #U8 len (bn_v b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t))
{Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 (8 * len)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.bn_to_bytes_le len b ==
Lib.ByteSequence.nat_to_intseq_le len (Hacl.Spec.Bignum.Definitions.bn_v b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_to_intseq_le",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Lib.IntTypes.uint8",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Prims.l_True",
"Prims.squash",
"Lib.IntTypes.int_t",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Lib.ByteSequence.index_nat_to_intseq_le",
"Prims._assert",
"Lib.Sequence.seq",
"FStar.Seq.Base.length",
"Prims.l_and",
"Lib.Sequence.length",
"Lib.IntTypes.bits",
"Lib.ByteSequence.nat_from_intseq_le",
"Lib.ByteSequence.uints_to_bytes_le",
"Lib.ByteSequence.lemma_nat_from_to_intseq_le_preserves_value",
"Hacl.Spec.Bignum.Convert.bn_v_is_nat_from_intseq_le_lemma",
"Lib.ByteSequence.uints_to_bytes_le_nat_lemma",
"FStar.Math.Lemmas.pow2_le_compat",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.op_Multiply",
"Prims.op_Addition",
"Prims.l_Forall",
"Lib.Sequence.sub",
"Prims.int",
"Prims.pos",
"Prims.op_Subtraction"
] | [] | false | false | true | false | false | let bn_to_bytes_le_lemma #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
let res = sub tmp 0 len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
uints_to_bytes_le_nat_lemma #t #SEC bnLen (bn_v b);
bn_v_is_nat_from_intseq_le_lemma bnLen b;
lemma_nat_from_to_intseq_le_preserves_value bnLen b;
assert (uints_to_bytes_le #t #SEC #bnLen b == nat_to_intseq_le #U8 tmpLen (bn_v b));
let aux (i: nat{i < len})
: Lemma
(index #uint8 #tmpLen (nat_to_intseq_le #U8 tmpLen (bn_v b)) i ==
index #uint8 #len (nat_to_intseq_le #U8 len (bn_v b)) i) =
index_nat_to_intseq_le #U8 #SEC tmpLen (bn_v b) i;
index_nat_to_intseq_le #U8 #SEC len (bn_v b) i
in
Classical.forall_intro aux;
eq_intro (nat_to_intseq_le #U8 #SEC len (bn_v b)) res | false |
Vale.X64.InsSha.fst | Vale.X64.InsSha.va_codegen_success_SHA256_rnds2 | val va_codegen_success_SHA256_rnds2 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_SHA256_rnds2 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_SHA256_rnds2 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsSha.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 28,
"start_col": 0,
"start_line": 27
} | module Vale.X64.InsSha
open Vale.Def.Types_s
open Vale.X64.Machine_s
open Vale.X64
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Decls
open Vale.X64.CryptoInstructions_s
open Spec.Hash.Definitions
open Spec.SHA2
open Vale.X64.CPU_Features_s
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
module P = Vale.X64.Print_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 2 --z3rlimit 20"
//-- SHA256_rnds2
[@ "opaque_to_smt"]
let va_code_SHA256_rnds2 dst src =
(mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.CryptoInstructions_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsSha.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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 | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_SHA256_rnds2 dst src =
| (va_ttrue ()) | false |
Vale.X64.InsSha.fst | Vale.X64.InsSha.va_codegen_success_SHA256_msg1 | val va_codegen_success_SHA256_msg1 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_SHA256_msg1 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_SHA256_msg1 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsSha.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 61,
"start_col": 0,
"start_line": 60
} | module Vale.X64.InsSha
open Vale.Def.Types_s
open Vale.X64.Machine_s
open Vale.X64
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Decls
open Vale.X64.CryptoInstructions_s
open Spec.Hash.Definitions
open Spec.SHA2
open Vale.X64.CPU_Features_s
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
module P = Vale.X64.Print_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 2 --z3rlimit 20"
//-- SHA256_rnds2
[@ "opaque_to_smt"]
let va_code_SHA256_rnds2 dst src =
(mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_SHA256_rnds2 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_SHA256_rnds2 va_b0 va_s0 dst src t block hash_orig =
va_reveal_opaque (`%va_code_SHA256_rnds2) (va_code_SHA256_rnds2 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
va_s0 in
lemma_sha256_rnds2 (va_eval_xmm va_old_s src) (va_eval_xmm va_old_s dst) (va_get_xmm 0 va_old_s)
t block hash_orig;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_SHA256_rnds2 dst src t block hash_orig va_s0 va_k =
let (va_sM, va_f0) = va_lemma_SHA256_rnds2 (va_code_SHA256_rnds2 dst src) va_s0 dst src t block
hash_orig in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- SHA256_msg1
[@ "opaque_to_smt"]
let va_code_SHA256_msg1 dst src =
(mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.CryptoInstructions_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsSha.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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 | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_SHA256_msg1 dst src =
| (va_ttrue ()) | false |
Pulse.Common.fst | Pulse.Common.for_all_dec | val for_all_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> bool)) : bool | val for_all_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> bool)) : bool | let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 42,
"start_col": 0,
"start_line": 39
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: 'a -> l: Prims.list 'b {l << top} -> f: (x: 'b{x << l} -> Prims.bool) -> Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.precedes",
"Prims.bool",
"Prims.op_AmpAmp",
"Pulse.Common.for_all_dec"
] | [
"recursion"
] | false | false | false | false | false | let rec for_all_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> bool)) : bool =
| match l with
| [] -> true
| x :: xs -> f x && for_all_dec top xs f | false |
Vale.X64.InsSha.fst | Vale.X64.InsSha.va_codegen_success_SHA256_msg2 | val va_codegen_success_SHA256_msg2 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | val va_codegen_success_SHA256_msg2 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_pbool | let va_codegen_success_SHA256_msg2 dst src =
(va_ttrue ()) | {
"file_name": "obj/Vale.X64.InsSha.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 92,
"start_col": 0,
"start_line": 91
} | module Vale.X64.InsSha
open Vale.Def.Types_s
open Vale.X64.Machine_s
open Vale.X64
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Decls
open Vale.X64.CryptoInstructions_s
open Spec.Hash.Definitions
open Spec.SHA2
open Vale.X64.CPU_Features_s
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
module P = Vale.X64.Print_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 2 --z3rlimit 20"
//-- SHA256_rnds2
[@ "opaque_to_smt"]
let va_code_SHA256_rnds2 dst src =
(mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_SHA256_rnds2 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_SHA256_rnds2 va_b0 va_s0 dst src t block hash_orig =
va_reveal_opaque (`%va_code_SHA256_rnds2) (va_code_SHA256_rnds2 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
va_s0 in
lemma_sha256_rnds2 (va_eval_xmm va_old_s src) (va_eval_xmm va_old_s dst) (va_get_xmm 0 va_old_s)
t block hash_orig;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_SHA256_rnds2 dst src t block hash_orig va_s0 va_k =
let (va_sM, va_f0) = va_lemma_SHA256_rnds2 (va_code_SHA256_rnds2 dst src) va_s0 dst src t block
hash_orig in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- SHA256_msg1
[@ "opaque_to_smt"]
let va_code_SHA256_msg1 dst src =
(mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_SHA256_msg1 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_SHA256_msg1 va_b0 va_s0 dst src t block =
va_reveal_opaque (`%va_code_SHA256_msg1) (va_code_SHA256_msg1 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src)))
va_s0 in
lemma_sha256_msg1 (va_eval_xmm va_old_s dst) (va_eval_xmm va_old_s src) t block;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_SHA256_msg1 dst src t block va_s0 va_k =
let (va_sM, va_f0) = va_lemma_SHA256_msg1 (va_code_SHA256_msg1 dst src) va_s0 dst src t block in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- SHA256_msg2
[@ "opaque_to_smt"]
let va_code_SHA256_msg2 dst src =
(mk_ins (make_instr (I.ins_SHA256_msg2) (OReg dst) (OReg src))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.CryptoInstructions_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsSha.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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 | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_SHA256_msg2 dst src =
| (va_ttrue ()) | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be_lemma_aux | val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8) | val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8) | let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
} | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 306,
"start_col": 0,
"start_line": 285
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len: Lib.IntTypes.size_pos{Lib.IntTypes.numbytes t * len <= Lib.IntTypes.max_size_t} ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t len
{Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 (Lib.IntTypes.bits t * len)} ->
i: Prims.nat{i < Lib.IntTypes.numbytes t * len}
-> FStar.Pervasives.Lemma
(ensures
(let numb = Lib.IntTypes.numbytes t in
Hacl.Spec.Bignum.Definitions.bn_v b / Prims.pow2 (8 * (numb * len - i - 1)) % Prims.pow2 8 ==
Lib.IntTypes.v b.[ len - i / numb - 1 ] / Prims.pow2 (8 * (numb - 1 - i % numb)) %
Prims.pow2 8)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.IntTypes.bits",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Division",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Addition",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_index",
"Prims.squash",
"FStar.Math.Lemmas.pow2_modulo_division_lemma_1",
"FStar.Math.Lemmas.division_multiplication_lemma",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1"
] | [] | false | false | true | false | false | let bn_to_bytes_be_lemma_aux #t len b i =
| let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc ( == ) {
v b.[ e1 ] / pow2 (8 * e) % pow2 8;
( == ) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
( == ) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
( == ) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1))
(pow2 (pbits * e1))
(pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
( == ) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
( == ) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2))
8
(pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
} | false |
Pulse.Common.fst | Pulse.Common.map_opt | val map_opt : f: (_: _ -> FStar.Pervasives.Native.option _) -> l: Prims.list _
-> FStar.Pervasives.Native.option (Prims.list _) | let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 68,
"start_col": 0,
"start_line": 63
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> [] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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: (_: _ -> FStar.Pervasives.Native.option _) -> l: Prims.list _
-> FStar.Pervasives.Native.option (Prims.list _) | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.option",
"Prims.list",
"FStar.Pervasives.Native.Some",
"Prims.Nil",
"Pulse.Common.op_let_Question",
"Pulse.Common.map_opt",
"Prims.Cons"
] | [
"recursion"
] | false | false | false | true | false | let rec map_opt f l =
| match l with
| [] -> Some []
| x :: xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y :: ys) | false |
|
Pulse.Common.fst | Pulse.Common.map_opt_dec | val map_opt_dec (#a #b #z: _) (top: z) (f: (x: a{x << top} -> option b)) (l: list a {l << top})
: option (list b) | val map_opt_dec (#a #b #z: _) (top: z) (f: (x: a{x << top} -> option b)) (l: list a {l << top})
: option (list b) | let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 16,
"end_line": 76,
"start_col": 0,
"start_line": 70
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: z -> f: (x: a{x << top} -> FStar.Pervasives.Native.option b) -> l: Prims.list a {l << top}
-> FStar.Pervasives.Native.option (Prims.list b) | Prims.Tot | [
"total"
] | [] | [
"Prims.precedes",
"FStar.Pervasives.Native.option",
"Prims.list",
"FStar.Pervasives.Native.Some",
"Prims.Nil",
"Pulse.Common.op_let_Question",
"Pulse.Common.map_opt_dec",
"Prims.Cons"
] | [
"recursion"
] | false | false | false | false | false | let rec map_opt_dec #a #b #z (top: z) (f: (x: a{x << top} -> option b)) (l: list a {l << top})
: option (list b) =
| match l with
| [] -> Some []
| x :: xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y :: ys) | false |
Pulse.Common.fst | Pulse.Common.map_dec | val map_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> 'c)) : list 'c | val map_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> 'c)) : list 'c | let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 47,
"start_col": 0,
"start_line": 44
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: 'a -> l: Prims.list 'b {l << top} -> f: (x: 'b{x << l} -> 'c) -> Prims.list 'c | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"Prims.precedes",
"Prims.Nil",
"Prims.Cons",
"Pulse.Common.map_dec"
] | [
"recursion"
] | false | false | false | false | false | let rec map_dec (top: 'a) (l: list 'b {l << top}) (f: (x: 'b{x << l} -> 'c)) : list 'c =
| match l with
| [] -> []
| x :: xs -> f x :: map_dec top xs f | false |
Steel.ST.Array.fst | Steel.ST.Array.compare | val compare (#t:eqtype) (#p0 #p1:perm)
(a0 a1:array t)
(#s0 #s1:Ghost.erased (Seq.seq t))
(l:US.t { US.v l == length a0 /\ length a0 == length a1 } )
: ST bool
(pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(fun _ -> pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(requires True)
(ensures fun b -> b <==> eq2 #(Seq.seq t) s0 s1) | val compare (#t:eqtype) (#p0 #p1:perm)
(a0 a1:array t)
(#s0 #s1:Ghost.erased (Seq.seq t))
(l:US.t { US.v l == length a0 /\ length a0 == length a1 } )
: ST bool
(pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(fun _ -> pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(requires True)
(ensures fun b -> b <==> eq2 #(Seq.seq t) s0 s1) | let compare
#t #p0 #p1 a0 a1 #s0 #s1 l
=
pts_to_length a0 _;
pts_to_length a1 _;
if l = 0sz
then (
assert (Seq.equal s0 s1);
return true
)
else (
compare_pts a0 a1 l
) | {
"file_name": "lib/steel/Steel.ST.Array.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 533,
"start_col": 0,
"start_line": 521
} | (*
Copyright 2020, 2021, 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law 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.ST.Array
module US = FStar.SizeT
/// Lifting a value of universe 0 to universe 1. We use
/// FStar.Universe, since FStar.Extraction.Krml is set to extract
/// those functions to identity.
inline_for_extraction
[@@ noextract_to "krml"]
let raise_t (t: Type0) : Type u#1 = FStar.Universe.raise_t t
inline_for_extraction
[@@noextract_to "krml"]
let raise (#t: Type) (x: t) : Tot (raise_t t) =
FStar.Universe.raise_val x
inline_for_extraction
[@@noextract_to "krml"]
let lower (#t: Type) (x: raise_t t) : Tot t =
FStar.Universe.downgrade_val x
/// A map operation on sequences. Here we only need Ghost versions,
/// because such sequences are only used in vprops or with their
/// selectors.
let rec seq_map
(#t: Type u#a)
(#t' : Type u#b)
(f: (t -> GTot t'))
(s: Seq.seq t)
: Ghost (Seq.seq t')
(requires True)
(ensures (fun s' ->
Seq.length s' == Seq.length s /\
(forall i . {:pattern (Seq.index s' i)} Seq.index s' i == f (Seq.index s i))
))
(decreases (Seq.length s))
= if Seq.length s = 0
then Seq.empty
else Seq.cons (f (Seq.index s 0)) (seq_map f (Seq.slice s 1 (Seq.length s)))
let seq_map_append
(#t: Type u#a)
(#t': Type u#b)
(f: (t -> GTot t'))
(s1 s2: Seq.seq t)
: Lemma
(seq_map f (s1 `Seq.append` s2) `Seq.equal` (seq_map f s1 `Seq.append` seq_map f s2))
= ()
let seq_map_raise_inj
(#elt: Type0)
(s1 s2: Seq.seq elt)
: Lemma
(requires (seq_map raise s1 == seq_map raise s2))
(ensures (s1 == s2))
[SMTPat (seq_map raise s1); SMTPat (seq_map raise s2)]
= assert (seq_map lower (seq_map raise s1) `Seq.equal` s1);
assert (seq_map lower (seq_map raise s2) `Seq.equal` s2)
/// Implementation of the interface
/// base, ptr, array, pts_to
module H = Steel.ST.HigherArray
let base_t elt = H.base_t (raise_t elt)
let base_len b = H.base_len b
let ptr elt = H.ptr (raise_t elt)
let null_ptr elt = H.null_ptr (raise_t elt)
let is_null_ptr p = H.is_null_ptr p
let base p = H.base p
let offset p = H.offset p
let ptr_base_offset_inj p1 p2 = H.ptr_base_offset_inj p1 p2
let base_len_null_ptr elt = H.base_len_null_ptr (raise_t elt)
let length_fits a = H.length_fits a
let pts_to a p s = H.pts_to a p (seq_map raise s)
let pts_to_length a s =
H.pts_to_length a _
let h_array_eq'
(#t: Type u#1)
(a1 a2: H.array t)
: Lemma
(requires (
dfst a1 == dfst a2 /\
(Ghost.reveal (dsnd a1) <: nat) == Ghost.reveal (dsnd a2)
))
(ensures (
a1 == a2
))
= ()
let pts_to_not_null #_ #t #p a s =
let _ = H.pts_to_not_null #_ #_ #p a (seq_map raise s) in
assert (a =!= H.null #(raise_t t));
Classical.move_requires (h_array_eq' a) (H.null #(raise_t t));
noop ()
let pts_to_inj a p1 s1 p2 s2 =
H.pts_to_inj a p1 (seq_map raise s1) p2 (seq_map raise s2)
/// Non-selector operations.
let malloc x n =
let res = H.malloc (raise x) n in
assert (seq_map raise (Seq.create (US.v n) x) `Seq.equal` Seq.create (US.v n) (raise x));
rewrite
(H.pts_to res _ _)
(pts_to res _ _);
return res
let free #_ x =
let s = elim_exists () in
rewrite
(pts_to x _ _)
(H.pts_to x P.full_perm (seq_map raise s));
H.free x
let share
#_ #_ #x a p p1 p2
= rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
H.share a p p1 p2;
rewrite
(H.pts_to a p1 _)
(pts_to a p1 x);
rewrite
(H.pts_to a p2 _)
(pts_to a p2 x)
let gather
#_ #_ a #x1 p1 #x2 p2
= rewrite
(pts_to a p1 _)
(H.pts_to a p1 (seq_map raise x1));
rewrite
(pts_to a p2 _)
(H.pts_to a p2 (seq_map raise x2));
H.gather a p1 p2;
rewrite
(H.pts_to a _ _)
(pts_to _ _ _)
let index #_ #p a #s i =
rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise s));
let res = H.index a i in
rewrite
(H.pts_to _ _ _)
(pts_to _ _ _);
return (lower res)
let upd #_ a #s i v =
rewrite
(pts_to a _ _)
(H.pts_to a P.full_perm (seq_map raise s));
H.upd a i (raise v);
assert (seq_map raise (Seq.upd s (US.v i) v) `Seq.equal` Seq.upd (seq_map raise s) (US.v i) (raise v));
rewrite
(H.pts_to _ _ _)
(pts_to _ _ _)
let ghost_join
#_ #_ #x1 #x2 #p a1 a2 h
= rewrite
(pts_to a1 _ _)
(H.pts_to a1 p (seq_map raise x1));
rewrite
(pts_to a2 _ _)
(H.pts_to a2 p (seq_map raise x2));
H.ghost_join a1 a2 h;
assert (seq_map raise (x1 `Seq.append` x2) `Seq.equal` (seq_map raise x1 `Seq.append` seq_map raise x2));
rewrite
(H.pts_to _ _ _)
(H.pts_to (merge a1 a2) p (seq_map raise (x1 `Seq.append` x2)));
rewrite
(H.pts_to _ _ _)
(pts_to (merge a1 a2) _ _)
let ptr_shift p off = H.ptr_shift p off
let ghost_split
#_ #_ #x #p a i
=
rewrite
(pts_to a _ _)
(H.pts_to a p (seq_map raise x));
let _ = H.ghost_split a i in
//H.ghost_split a i;
assert (seq_map raise (Seq.slice x 0 (US.v i)) `Seq.equal` Seq.slice (seq_map raise x) 0 (US.v i));
rewrite
(H.pts_to (H.split_l a i) _ _)
(H.pts_to (split_l a i) p (seq_map raise (Seq.slice x 0 (US.v i))));
rewrite
(H.pts_to (split_l a i) _ _)
(pts_to (split_l a i) _ _);
assert (seq_map raise (Seq.slice x (US.v i) (Seq.length x)) `Seq.equal` Seq.slice (seq_map raise x) (US.v i) (Seq.length (seq_map raise x)));
Seq.lemma_split x (US.v i);
rewrite
(H.pts_to (H.split_r a i) _ _)
(H.pts_to (split_r a i) p (seq_map raise (Seq.slice x (US.v i) (Seq.length x))));
rewrite
(H.pts_to (split_r a i) _ _)
(pts_to (split_r a i) _ _)
let memcpy
a0 a1 l
=
H.memcpy a0 a1 l
////////////////////////////////////////////////////////////////////////////////
// compare
////////////////////////////////////////////////////////////////////////////////
module R = Steel.ST.Reference
#push-options "--fuel 0 --ifuel 1 --z3rlimit_factor 2"
let equal_up_to #t
(s0: Seq.seq t)
(s1: Seq.seq t)
(v : option US.t) : prop =
Seq.length s0 = Seq.length s1 /\
(match v with
| None -> Ghost.reveal s0 =!= Ghost.reveal s1
| Some v -> US.v v <= Seq.length s0 /\ Seq.slice s0 0 (US.v v) `Seq.equal` Seq.slice s1 0 (US.v v))
let within_bounds (x:option US.t) (l:US.t) (b:Ghost.erased bool) : prop =
if b then Some? x /\ US.(Some?.v x <^ l)
else None? x \/ US.(Some?.v x >=^ l)
let compare_inv (#t:eqtype) (#p0 #p1:perm)
(a0 a1:array t)
(s0: Seq.seq t)
(s1: Seq.seq t)
(l:US.t)
(ctr : R.ref (option US.t))
(b: bool) =
pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
exists_ (fun (x:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm x `star`
pure (equal_up_to s0 s1 x) `star`
pure (within_bounds x l b))
let elim_compare_inv #o
(#t:eqtype)
(#p0 #p1:perm)
(a0 a1:array t)
(#s0: Seq.seq t)
(#s1: Seq.seq t)
(l:US.t)
(ctr : R.ref (option US.t))
(b: bool)
: STGhostT (Ghost.erased (option US.t)) o
(compare_inv a0 a1 s0 s1 l ctr b)
(fun x ->
let open US in
pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
R.pts_to ctr Steel.FractionalPermission.full_perm x `star`
pure (equal_up_to s0 s1 x) `star`
pure (within_bounds x l b))
= let open US in
assert_spinoff
((compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr b) ==
(pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
exists_ (fun (v:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm v `star`
pure (equal_up_to s0 s1 v) `star`
pure (within_bounds v l b))));
rewrite
(compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr b)
(pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
exists_ (fun (v:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm v `star`
pure (equal_up_to s0 s1 v) `star`
pure (within_bounds v l b)));
let _v = elim_exists () in
_v
let intro_compare_inv #o
(#t:eqtype)
(#p0 #p1:perm)
(a0 a1:array t)
(#s0: Seq.seq t)
(#s1: Seq.seq t)
(l:US.t)
(ctr : R.ref (option US.t))
(x: Ghost.erased (option US.t))
(b:bool { within_bounds x l b })
: STGhostT unit o
(let open US in
pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
R.pts_to ctr Steel.FractionalPermission.full_perm x `star`
pure (equal_up_to s0 s1 x))
(fun _ -> compare_inv a0 a1 s0 s1 l ctr (Ghost.hide b))
= let open US in
intro_pure (within_bounds x l (Ghost.hide b));
intro_exists_erased x (fun (x:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm x `star`
pure (equal_up_to s0 s1 x) `star`
pure (within_bounds x l (Ghost.hide b)));
assert_norm
((compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr (Ghost.hide b)) ==
(pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
exists_ (fun (v:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm v `star`
pure (equal_up_to s0 s1 v) `star`
pure (within_bounds v l (Ghost.hide b)))));
rewrite
(pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
exists_ (fun (v:option US.t) ->
R.pts_to ctr Steel.FractionalPermission.full_perm v `star`
pure (equal_up_to s0 s1 v) `star`
pure (within_bounds v l (Ghost.hide b))))
(compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr (Ghost.hide b))
let intro_exists_compare_inv #o
(#t:eqtype)
(#p0 #p1:perm)
(a0 a1:array t)
(#s0: Seq.seq t)
(#s1: Seq.seq t)
(l:US.t)
(ctr : R.ref (option US.t))
(x: Ghost.erased (option US.t))
: STGhostT unit o
(let open US in
pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
R.pts_to ctr Steel.FractionalPermission.full_perm x `star`
pure (equal_up_to s0 s1 x))
(fun _ -> exists_ (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr))
= let b : bool =
match Ghost.reveal x with
| None -> false
| Some x -> US.(x <^ l)
in
assert (within_bounds x l b);
intro_compare_inv #_ #_ #p0 #p1 a0 a1 #s0 #s1 l ctr x b;
intro_exists _ (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr)
let extend_equal_up_to_lemma (#t:Type0)
(s0:Seq.seq t)
(s1:Seq.seq t)
(i:nat{ i < Seq.length s0 /\ Seq.length s0 == Seq.length s1 })
: Lemma
(requires
Seq.equal (Seq.slice s0 0 i) (Seq.slice s1 0 i) /\
Seq.index s0 i == Seq.index s1 i)
(ensures
Seq.equal (Seq.slice s0 0 (i + 1)) (Seq.slice s1 0 (i + 1)))
= assert (forall k. k < i ==> Seq.index s0 k == Seq.index (Seq.slice s0 0 i) k /\
Seq.index s1 k == Seq.index (Seq.slice s1 0 i) k)
let extend_equal_up_to (#o:_)
(#t:Type0)
(#s0:Seq.seq t)
(#s1:Seq.seq t)
(len:US.t)
(i:US.t{ Seq.length s0 == Seq.length s1 /\ US.(i <^ len) /\ US.v len == Seq.length s0 } )
: STGhost unit o
(pure (equal_up_to s0 s1 (Some i)))
(fun _ -> pure (equal_up_to s0 s1 (Some US.(i +^ 1sz))))
(requires
Seq.index s0 (US.v i) == Seq.index s1 (US.v i))
(ensures fun _ -> True)
= elim_pure _;
extend_equal_up_to_lemma s0 s1 (US.v i);
intro_pure (equal_up_to s0 s1 (Some US.(i +^ 1sz)))
let extend_equal_up_to_neg (#o:_)
(#t:Type0)
(#s0:Seq.seq t)
(#s1:Seq.seq t)
(len:US.t)
(i:US.t{ Seq.length s0 == Seq.length s1 /\ US.(i <^ len) /\ US.v len == Seq.length s0 } )
: STGhost unit o
(pure (equal_up_to s0 s1 (Some i)))
(fun _ -> pure (equal_up_to s0 s1 None))
(requires
Seq.index s0 (US.v i) =!= Seq.index s1 (US.v i))
(ensures fun _ -> True)
= elim_pure _;
intro_pure _
let init_compare_inv #o
(#t:eqtype)
(#p0 #p1:perm)
(a0 a1:array t)
(#s0: Seq.seq t)
(#s1: Seq.seq t)
(l:US.t)
(ctr : R.ref (option US.t))
: STGhost unit o
(let open US in
pts_to a0 p0 s0 `star`
pts_to a1 p1 s1 `star`
R.pts_to ctr Steel.FractionalPermission.full_perm (Some 0sz))
(fun _ -> exists_ (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr))
(requires (
length a0 > 0 /\
length a0 == length a1 /\
US.v l == length a0
))
(ensures (fun _ -> True))
= pts_to_length a0 _;
pts_to_length a1 _;
intro_pure (equal_up_to s0 s1 (Ghost.hide (Some 0sz)));
rewrite
(R.pts_to ctr Steel.FractionalPermission.full_perm (Some 0sz))
(R.pts_to ctr Steel.FractionalPermission.full_perm (Ghost.hide (Some 0sz)));
intro_exists_compare_inv a0 a1 l ctr (Ghost.hide (Some 0sz))
let compare_pts
(#t:eqtype)
(#p0 #p1:perm)
(a0 a1:array t)
(#s0: Ghost.erased (Seq.seq t))
(#s1: Ghost.erased (Seq.seq t))
(l:US.t)
: ST bool
(pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(fun _ -> pts_to a0 p0 s0 `star` pts_to a1 p1 s1)
(requires
length a0 > 0 /\ length a0 == length a1 /\ US.v l == length a0
)
(ensures fun b ->
b = (Ghost.reveal s0 = Ghost.reveal s1))
=
pts_to_length a0 _;
pts_to_length a1 _;
let ctr = R.alloc (Some 0sz) in
let cond ()
: STT bool
(exists_ (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr))
(fun b -> compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr (Ghost.hide b))
= let _b = elim_exists () in
let _ = elim_compare_inv _ _ _ _ _ in
let x = R.read ctr in
elim_pure (within_bounds _ _ _);
match x with
| None ->
intro_compare_inv #_ #_ #p0 #p1 a0 a1 l ctr _ false;
return false
| Some x ->
let res = US.(x <^ l) in
intro_compare_inv #_ #_ #p0 #p1 a0 a1 l ctr _ res;
return res
in
let body ()
: STT unit
(compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr (Ghost.hide true))
(fun _ -> exists_ (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr))
= let _i = elim_compare_inv _ _ _ _ _ in
elim_pure (within_bounds _ _ _);
let Some i = R.read ctr in
assert_spinoff
((pure (equal_up_to s0 s1 _i)) ==
(pure (equal_up_to s0 s1 (Some i))));
rewrite
(pure (equal_up_to s0 s1 _i))
(pure (equal_up_to s0 s1 (Some i)));
let v0 = index a0 i in
let v1 = index a1 i in
if v0 = v1
then (
R.write ctr (Some US.(i +^ 1sz));
extend_equal_up_to l i;
intro_exists_compare_inv #_ #_ #p0 #p1 a0 a1 l ctr (Ghost.hide (Some (US.(i +^ 1sz))))
)
else (
R.write ctr None;
extend_equal_up_to_neg l i;
intro_exists_compare_inv #_ #_ #p0 #p1 a0 a1 l ctr (Ghost.hide None)
)
in
init_compare_inv a0 a1 l ctr;
Steel.ST.Loops.while_loop (compare_inv #_ #p0 #p1 a0 a1 s0 s1 l ctr)
cond
body;
let _ = elim_compare_inv _ _ _ _ _ in
elim_pure (equal_up_to _ _ _);
let v = R.read ctr in
R.free ctr;
elim_pure (within_bounds _ _ _);
match v with
| None -> return false
| Some _ -> return true | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Reference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.ST.HigherArray.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.Array.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.ST.Reference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Steel.ST.HigherArray",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.PtrdiffT",
"short_module": "UP"
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.FractionalPermission",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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": 1,
"max_fuel": 0,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 2,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false |
a0: Steel.ST.Array.array t ->
a1: Steel.ST.Array.array t ->
l:
FStar.SizeT.t
{ FStar.SizeT.v l == Steel.ST.Array.length a0 /\
Steel.ST.Array.length a0 == Steel.ST.Array.length a1 }
-> Steel.ST.Effect.ST Prims.bool | Steel.ST.Effect.ST | [] | [] | [
"Prims.eqtype",
"Steel.FractionalPermission.perm",
"Steel.ST.Array.array",
"FStar.Ghost.erased",
"FStar.Seq.Base.seq",
"FStar.SizeT.t",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.SizeT.v",
"Steel.ST.Array.length",
"Prims.op_Equality",
"FStar.SizeT.__uint_to_t",
"Steel.ST.Util.return",
"Prims.bool",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Effect.Common.VStar",
"Steel.ST.Array.pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Steel.ST.Array.compare_pts",
"Steel.ST.Array.pts_to_length"
] | [] | false | true | false | false | false | let compare #t #p0 #p1 a0 a1 #s0 #s1 l =
| pts_to_length a0 _;
pts_to_length a1 _;
if l = 0sz
then
(assert (Seq.equal s0 s1);
return true)
else (compare_pts a0 a1 l) | false |
Pulse.Common.fst | Pulse.Common.zip | val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)}) | val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)}) | let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> [] | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 13,
"end_line": 61,
"start_col": 0,
"start_line": 59
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | l1: Prims.list a -> l2: Prims.list b
-> l:
Prims.list (a * b)
{ FStar.List.Tot.Base.length l ==
Prims.min (FStar.List.Tot.Base.length l1) (FStar.List.Tot.Base.length l2) } | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Cons",
"FStar.Pervasives.Native.tuple2",
"Pulse.Common.zip",
"Prims.Nil",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.min"
] | [
"recursion"
] | false | false | false | false | false | let rec zip #a #b l1 l2 =
| match l1, l2 with
| x :: xs, y :: ys -> (x, y) :: (zip xs ys)
| _ -> [] | false |
Pulse.Common.fst | Pulse.Common.concat_map_opt | val concat_map_opt (#a #b: _) (f: (a -> option (list b))) (l: list a) : option (list b) | val concat_map_opt (#a #b: _) (f: (a -> option (list b))) (l: list a) : option (list b) | let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 15,
"end_line": 84,
"start_col": 0,
"start_line": 78
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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.Pervasives.Native.option (Prims.list b)) -> l: Prims.list a
-> FStar.Pervasives.Native.option (Prims.list b) | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.option",
"Prims.list",
"FStar.Pervasives.Native.Some",
"Prims.Nil",
"Pulse.Common.op_let_Question",
"Pulse.Common.concat_map_opt",
"FStar.List.Tot.Base.append"
] | [
"recursion"
] | false | false | false | true | false | let rec concat_map_opt #a #b (f: (a -> option (list b))) (l: list a) : option (list b) =
| match l with
| [] -> Some []
| x :: xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y @ ys) | false |
BitFields.fst | BitFields.bitfield_group | val bitfield_group : Type0 | let bitfield_group = int & typ & list atomic_field | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 50,
"end_line": 31,
"start_col": 0,
"start_line": 31
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.Native.tuple3",
"Prims.int",
"Ast.typ",
"Prims.list",
"Ast.atomic_field"
] | [] | false | false | false | true | true | let bitfield_group =
| int & typ & list atomic_field | false |
|
Pulse.Common.fst | Pulse.Common.lemma_map_opt_dec_len | val lemma_map_opt_dec_len
(#a #b #z: _)
(top: z)
(f: (x: a{x << top} -> option b))
(xs: list a {xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)] | val lemma_map_opt_dec_len
(#a #b #z: _)
(top: z)
(f: (x: a{x << top} -> option b))
(xs: list a {xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)] | let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 45,
"end_line": 92,
"start_col": 0,
"start_line": 86
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: z -> f: (x: a{x << top} -> FStar.Pervasives.Native.option b) -> xs: Prims.list a {xs << top}
-> FStar.Pervasives.Lemma (requires Some? (Pulse.Common.map_opt_dec top f xs))
(ensures
FStar.List.Tot.Base.length (Some?.v (Pulse.Common.map_opt_dec top f xs)) ==
FStar.List.Tot.Base.length xs)
[SMTPat (Pulse.Common.map_opt_dec top f xs)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"FStar.Pervasives.Native.option",
"Prims.list",
"Pulse.Common.lemma_map_opt_dec_len",
"Prims.unit",
"Prims.b2t",
"FStar.Pervasives.Native.uu___is_Some",
"Pulse.Common.map_opt_dec",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_map_opt_dec_len
#a
#b
#z
(top: z)
(f: (x: a{x << top} -> option b))
(xs: list a {xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)] =
| match xs with
| [] -> ()
| x :: xs -> lemma_map_opt_dec_len top f xs | false |
Pulse.Common.fst | Pulse.Common.zipWith | val zipWith (f: ('a -> 'b -> Tac 'c)) (l: list 'a) (m: list 'b)
: Tac (l': (list 'c){L.length l' == min (L.length l) (L.length m)}) | val zipWith (f: ('a -> 'b -> Tac 'c)) (l: list 'a) (m: list 'b)
: Tac (l': (list 'c){L.length l' == min (L.length l) (L.length m)}) | let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch" | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 40,
"end_line": 55,
"start_col": 0,
"start_line": 49
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 -> FStar.Tactics.Effect.Tac 'c) -> l: Prims.list 'a -> m: Prims.list 'b
-> FStar.Tactics.Effect.Tac
(l':
Prims.list 'c
{ FStar.List.Tot.Base.length l' ==
Prims.min (FStar.List.Tot.Base.length l) (FStar.List.Tot.Base.length m) }) | FStar.Tactics.Effect.Tac | [] | [] | [
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Nil",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"Prims.min",
"Prims.Cons",
"Pulse.Common.zipWith",
"FStar.Pervasives.Native.tuple2",
"FStar.Tactics.V1.Derived.fail"
] | [
"recursion"
] | false | true | false | false | false | let rec zipWith (f: ('a -> 'b -> Tac 'c)) (l: list 'a) (m: list 'b)
: Tac (l': (list 'c){L.length l' == min (L.length l) (L.length m)}) =
| match l, m with
| [], [] -> []
| x :: xs, y :: ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch" | false |
BitFields.fst | BitFields.subst' | val subst' : Type0 | let subst' = list (ident & expr) | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 32,
"end_line": 64,
"start_col": 0,
"start_line": 64
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*)
let bitfield_group = int & typ & list atomic_field
let grouped_fields = either field bitfield_group
let group_bit_fields (rewrite_composite_field: field -> ML field)
(fields: list field)
: ML (list grouped_fields)
= List.fold_right
(fun field out ->
match field.v with
| RecordField _ _
| SwitchCaseField _ _ ->
Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None ->
Inl field :: out
| Some (Inl _) ->
failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields)::tl ->
if index = bf.v.bitfield_identifier
then Inr(index, typ, af :: atomic_fields) :: tl //extend this bitfield group
else Inr(bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
)
fields
[] | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Ast.ident",
"Ast.expr"
] | [] | false | false | false | true | true | let subst' =
| list (ident & expr) | false |
|
Pulse.Common.fst | Pulse.Common.lemma_map_dec_index | val lemma_map_dec_index (top: 'z) (f: (x: 'a{x << top} -> 'b)) (xs: list 'a {xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == (map_dec top xs f) `L.index` i) | val lemma_map_dec_index (top: 'z) (f: (x: 'a{x << top} -> 'b)) (xs: list 'a {xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == (map_dec top xs f) `L.index` i) | let lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}) -> 'b) (xs : list 'a{xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == map_dec top xs f `L.index` i)
= Classical.forall_intro (Classical.move_requires (__lemma_map_dec_index top f xs (map_dec top xs f))) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 104,
"end_line": 142,
"start_col": 0,
"start_line": 140
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys))
let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1)
let rec lemma_map_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> b) (xs : list a{xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs))
[SMTPat (map_dec top xs f)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_dec_len top f xs
let rec __lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}-> 'b)) (xs : list 'a{xs << top}) (ys : list 'b) (i:nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f)
(ensures f (xs `L.index` i) == ys `L.index` i)
= match xs, ys, i with
| _, _, 0 -> ()
| x::xs, y::ys, _ ->
__lemma_map_dec_index top f xs ys (i-1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: 'z -> f: (x: 'a{x << top} -> 'b) -> xs: Prims.list 'a {xs << top}
-> FStar.Pervasives.Lemma
(ensures
forall (i:
Prims.nat
{ i < FStar.List.Tot.Base.length xs /\
i < FStar.List.Tot.Base.length (Pulse.Common.map_dec top xs f) }).
f (FStar.List.Tot.Base.index xs i) ==
FStar.List.Tot.Base.index (Pulse.Common.map_dec top xs f) i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"Prims.list",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Prims.l_imp",
"Prims.eq2",
"Pulse.Common.map_dec",
"FStar.List.Tot.Base.index",
"FStar.Classical.move_requires",
"Pulse.Common.__lemma_map_dec_index",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_Forall",
"Prims.l_and",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let lemma_map_dec_index (top: 'z) (f: (x: 'a{x << top} -> 'b)) (xs: list 'a {xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == (map_dec top xs f) `L.index` i) =
| Classical.forall_intro (Classical.move_requires (__lemma_map_dec_index top f xs (map_dec top xs f))) | false |
BitFields.fst | BitFields.grouped_fields | val grouped_fields : Type0 | let grouped_fields = either field bitfield_group | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 48,
"end_line": 32,
"start_col": 0,
"start_line": 32
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | Type0 | Prims.Tot | [
"total"
] | [] | [
"Ast.either",
"Ast.field",
"BitFields.bitfield_group"
] | [] | false | false | false | true | true | let grouped_fields =
| either field bitfield_group | false |
|
Pulse.Common.fst | Pulse.Common.dec_index | val dec_index (#a: _) (top: 'z) (l: list a {l << top}) (i: nat{i < L.length l})
: Lemma (l `L.index` i << top) [SMTPat (l `L.index` i << top)] | val dec_index (#a: _) (top: 'z) (l: list a {l << top}) (i: nat{i < L.length l})
: Lemma (l `L.index` i << top) [SMTPat (l `L.index` i << top)] | let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 36,
"end_line": 113,
"start_col": 0,
"start_line": 108
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: 'z -> l: Prims.list a {l << top} -> i: Prims.nat{i < FStar.List.Tot.Base.length l}
-> FStar.Pervasives.Lemma (ensures FStar.List.Tot.Base.index l i << top)
[SMTPat (FStar.List.Tot.Base.index l i << top)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.list",
"Prims.precedes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"Prims.int",
"Pulse.Common.dec_index",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.List.Tot.Base.index",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec dec_index #a (top: 'z) (l: list a {l << top}) (i: nat{i < L.length l})
: Lemma (l `L.index` i << top) [SMTPat (l `L.index` i << top)] =
| match l, i with
| _, 0 -> ()
| _ :: l, _ -> dec_index top l (i - 1) | false |
Pulse.Common.fst | Pulse.Common.__lemma_map_dec_index | val __lemma_map_dec_index
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(ys: list 'b)
(i: nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f) (ensures f (xs `L.index` i) == ys `L.index` i) | val __lemma_map_dec_index
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(ys: list 'b)
(i: nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f) (ensures f (xs `L.index` i) == ys `L.index` i) | let rec __lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}-> 'b)) (xs : list 'a{xs << top}) (ys : list 'b) (i:nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f)
(ensures f (xs `L.index` i) == ys `L.index` i)
= match xs, ys, i with
| _, _, 0 -> ()
| x::xs, y::ys, _ ->
__lemma_map_dec_index top f xs ys (i-1) | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 44,
"end_line": 138,
"start_col": 0,
"start_line": 132
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys))
let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1)
let rec lemma_map_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> b) (xs : list a{xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs))
[SMTPat (map_dec top xs f)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_dec_len top f xs | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 |
top: 'z ->
f: (x: 'a{x << top} -> 'b) ->
xs: Prims.list 'a {xs << top} ->
ys: Prims.list 'b ->
i: Prims.nat{i < FStar.List.Tot.Base.length xs}
-> FStar.Pervasives.Lemma (requires ys == Pulse.Common.map_dec top xs f)
(ensures f (FStar.List.Tot.Base.index xs i) == FStar.List.Tot.Base.index ys i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"FStar.Pervasives.Native.Mktuple3",
"Prims.int",
"Pulse.Common.__lemma_map_dec_index",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.eq2",
"Pulse.Common.map_dec",
"Prims.squash",
"FStar.List.Tot.Base.index",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [
"recursion"
] | false | false | true | false | false | let rec __lemma_map_dec_index
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(ys: list 'b)
(i: nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f) (ensures f (xs `L.index` i) == ys `L.index` i) =
| match xs, ys, i with
| _, _, 0 -> ()
| x :: xs, y :: ys, _ -> __lemma_map_dec_index top f xs ys (i - 1) | false |
BitFields.fst | BitFields.eliminate_decls | val eliminate_decls (env: B.global_env) (ds: list decl) : ML (list decl) | val eliminate_decls (env: B.global_env) (ds: list decl) : ML (list decl) | let eliminate_decls (env:B.global_env) (ds:list decl) : ML (list decl) =
List.map (eliminate_one_decl env) ds | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 38,
"end_line": 190,
"start_col": 0,
"start_line": 189
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*)
let bitfield_group = int & typ & list atomic_field
let grouped_fields = either field bitfield_group
let group_bit_fields (rewrite_composite_field: field -> ML field)
(fields: list field)
: ML (list grouped_fields)
= List.fold_right
(fun field out ->
match field.v with
| RecordField _ _
| SwitchCaseField _ _ ->
Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None ->
Inl field :: out
| Some (Inl _) ->
failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields)::tl ->
if index = bf.v.bitfield_identifier
then Inr(index, typ, af :: atomic_fields) :: tl //extend this bitfield group
else Inr(bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
)
fields
[]
let subst' = list (ident & expr)
let coalesce_grouped_bit_field env (f:bitfield_group)
: ML (field & subst')
= let id, typ, fields = f in
let size = B.size_of_integral_typ env typ typ.range in
let bitsize = 8 * size in
let order = B.bit_order_of_integral_typ env typ typ.range in
let field_id = with_range (to_ident' (Printf.sprintf "__bitfield_%d" id)) dummy_range in
let id = with_range (Identifier field_id) field_id.range in
let mk_e (e:expr') :expr = with_range e field_id.range in
let bitfield_attrs f : ML _ =
match f.field_bitwidth with
| Some (Inr bf) -> bf.v
| _ -> failwith "Must have elaborated bitfield"
in
let field_dependence, field_constraint, field_action, subst =
List.fold_left
(fun (acc:(bool & _ & option (action & bool) & _)) f ->
let (dep, acc_constraint, acc_action, subst) = acc in
let f = f.v in
let acc_action, acc_dep =
match acc_action, f.field_action with
| None, None
| Some _, None -> acc_action, false
| None, Some (_, d) -> f.field_action, d
| Some (acc, dep_0), Some (fa, dep_1) ->
if Action_act? acc.v
&& Action_act? fa.v
then
Some (Ast.sequence_non_failing_actions acc fa, dep_0 || dep_1),
dep_0 || dep_1
else
failwith "Multiple, potentially failing actions are not supported on bitfields"
in
let dep = dep || acc_dep || f.field_dependence in
let acc_constraint =
match f.field_constraint, acc_constraint with
| None, _ -> acc_constraint
| Some _, None -> f.field_constraint
| Some c, Some acc -> Some (mk_e (App And [acc; c]))
in
let bf_exp =
App
(BitFieldOf bitsize order)
[id;
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_from));
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_to))]
in
let subst = (f.field_ident, mk_e bf_exp) :: subst in
dep, acc_constraint, acc_action, subst)
(false, None, None, [])
fields
in
let struct_field = {
field_dependence = field_dependence;
field_ident = field_id;
field_type = typ;
field_array_opt = FieldScalar;
field_constraint = field_constraint;
field_bitwidth = None;
field_action = field_action;
field_probe = None
} in
let af = with_dummy_range struct_field in
with_dummy_range (AtomicField af),
subst
let rec rewrite_field (env:B.global_env) (f:field)
: ML (f':field {field_tag_equal f f'})
= match f.v with
| AtomicField _ -> f
| RecordField fs field_name ->
let gfs = group_bit_fields (rewrite_field env) fs in
let fs, subst =
List.fold_right
(fun f (fields, subst) ->
match f with
| Inl f -> (f::fields, subst)
| Inr gf ->
let f, subst' = coalesce_grouped_bit_field (B.mk_env env) gf in
f::fields, subst'@subst)
gfs
([], [])
in
let fs = List.map (subst_field (mk_subst subst)) fs in
{ f with v = RecordField fs field_name }
| SwitchCaseField (e, cases) field_name ->
let cases =
List.map
(function
| Case p f ->
Case p (rewrite_field env f)
| DefaultCase f ->
DefaultCase (rewrite_field env f))
cases
in
{ f with v = SwitchCaseField (e, cases) field_name }
let eliminate_one_decl (env:B.global_env) (d:decl) : ML decl =
match d.d_decl.v with
| Record names params where fields ->
let i = with_dummy_range (to_ident' "_") in
let { v = RecordField fields _ } = rewrite_field env (with_dummy_range (RecordField fields i)) in
List.iter (fun f ->
Options.debug_print_string
(Printf.sprintf "Bitfields: Field %s has comments <%s>\n"
(print_field f)
(String.concat "\n" f.comments))) fields;
let fields =
match fields with
| [{v=AtomicField af; range; comments}] -> //just one field, it need no longer be dependent
let af' = { af.v with field_dependence = false } in
let af' = { af with v = af' } in
[{v=AtomicField af; range; comments}]
| _ -> fields
in
decl_with_v d (Record names params where fields)
| _ -> d | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | env: GlobalEnv.global_env -> ds: Prims.list Ast.decl -> FStar.All.ML (Prims.list Ast.decl) | FStar.All.ML | [
"ml"
] | [] | [
"GlobalEnv.global_env",
"Prims.list",
"Ast.decl",
"FStar.List.map",
"BitFields.eliminate_one_decl"
] | [] | false | true | false | false | false | let eliminate_decls (env: B.global_env) (ds: list decl) : ML (list decl) =
| List.map (eliminate_one_decl env) ds | false |
Pulse.Common.fst | Pulse.Common.lemma_map_dec_index_i | val lemma_map_dec_index_i
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(i: nat{i < L.length xs})
: Lemma (ensures f (xs `L.index` i) == (map_dec top xs f) `L.index` i) | val lemma_map_dec_index_i
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(i: nat{i < L.length xs})
: Lemma (ensures f (xs `L.index` i) == (map_dec top xs f) `L.index` i) | let lemma_map_dec_index_i (top:'z) (f : (x:'a{x<<top}) -> 'b) (xs : list 'a{xs << top}) (i : nat {i < L.length xs})
: Lemma (ensures f (xs `L.index` i) == map_dec top xs f `L.index` i)
= lemma_map_dec_index top f xs | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 32,
"end_line": 146,
"start_col": 0,
"start_line": 144
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys))
let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1)
let rec lemma_map_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> b) (xs : list a{xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs))
[SMTPat (map_dec top xs f)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_dec_len top f xs
let rec __lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}-> 'b)) (xs : list 'a{xs << top}) (ys : list 'b) (i:nat{i < L.length xs})
: Lemma (requires ys == map_dec top xs f)
(ensures f (xs `L.index` i) == ys `L.index` i)
= match xs, ys, i with
| _, _, 0 -> ()
| x::xs, y::ys, _ ->
__lemma_map_dec_index top f xs ys (i-1)
let lemma_map_dec_index (top:'z) (f : (x:'a{x<<top}) -> 'b) (xs : list 'a{xs << top})
: Lemma (ensures forall i. f (xs `L.index` i) == map_dec top xs f `L.index` i)
= Classical.forall_intro (Classical.move_requires (__lemma_map_dec_index top f xs (map_dec top xs f))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 |
top: 'z ->
f: (x: 'a{x << top} -> 'b) ->
xs: Prims.list 'a {xs << top} ->
i: Prims.nat{i < FStar.List.Tot.Base.length xs}
-> FStar.Pervasives.Lemma
(ensures
f (FStar.List.Tot.Base.index xs i) ==
FStar.List.Tot.Base.index (Pulse.Common.map_dec top xs f) i) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"Prims.list",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.List.Tot.Base.length",
"Pulse.Common.lemma_map_dec_index",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.List.Tot.Base.index",
"Pulse.Common.map_dec",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let lemma_map_dec_index_i
(top: 'z)
(f: (x: 'a{x << top} -> 'b))
(xs: list 'a {xs << top})
(i: nat{i < L.length xs})
: Lemma (ensures f (xs `L.index` i) == (map_dec top xs f) `L.index` i) =
| lemma_map_dec_index top f xs | false |
Steel.ST.GhostPCMReference.fst | Steel.ST.GhostPCMReference.gather | val gather (#o:inames)
(#a:Type)
(#p:FStar.PCM.pcm a)
(r:ref a p)
(v0:a)
(v1:a)
: STGhostT (_:unit{composable p v0 v1}) o
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op p v0 v1)) | val gather (#o:inames)
(#a:Type)
(#p:FStar.PCM.pcm a)
(r:ref a p)
(v0:a)
(v1:a)
: STGhostT (_:unit{composable p v0 v1}) o
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op p v0 v1)) | let gather (#o:inames)
(#a:Type)
(#p:FStar.PCM.pcm a)
(r:ref a p)
(v0:a)
(v1:a)
: STGhostT (_:unit{composable p v0 v1}) o
(pts_to r v0 `star` pts_to r v1)
(fun _ -> pts_to r (op p v0 v1))
= let _ = coerce_ghost (fun _ -> G.gather r (raise_val v0) (raise_val v1)) in
() | {
"file_name": "lib/steel/Steel.ST.GhostPCMReference.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 6,
"end_line": 110,
"start_col": 0,
"start_line": 100
} | (*
Copyright 2021 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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.ST.GhostPCMReference
open FStar.Ghost
open Steel.ST.Util
open Steel.ST.Coercions
open FStar.PCM
open FStar.Universe
module UP = FStar.Universe.PCM
module G = Steel.GhostPCMReference
let ref (a:Type u#0) (p:pcm a) : Type u#0 =
G.ref (raise_t u#0 u#1 a) (UP.raise p)
/// pts_to is fixed to ref contents in u#0
let pts_to (#a:Type u#0) (#pcm:pcm a) (r:ref a pcm) ([@@@smt_fallback] v:a)
= G.pts_to #(raise_t a) #(UP.raise pcm) r (raise_val v)
/// Allocates a new reference, initially storing value [x].
let alloc (#o:inames)
(#a:Type)
(#pcm:pcm a)
(x:a)
: STGhost (ref a pcm) o
emp
(fun r -> pts_to r x)
(requires pcm.refine x)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> G.alloc (raise_val x))
let read (#o:inames)
(#a:Type)
(#pcm:pcm a)
(#v0:a)
(r:ref a pcm)
: STGhost a o
(pts_to r v0)
(fun _ -> pts_to r v0)
(requires True)
(ensures fun v -> compatible pcm v0 v)
= let v = coerce_ghost (fun _ -> G.read r) in
downgrade_val v
let write (#o:inames)
(#a:Type)
(#pcm:pcm a)
(r:ref a pcm)
(v0:a)
(v1:a)
: STGhost unit o
(pts_to r v0)
(fun _ -> pts_to r v1)
(requires frame_preserving pcm v0 v1 /\ pcm.refine v1)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> G.write r (raise_val v0) (raise_val v1))
let upd_gen (#o:inames)
(#a:Type)
(#p:pcm a)
(r:ref a p)
(x y:a)
(f:frame_preserving_upd p x y)
: STGhostT unit o
(pts_to r x)
(fun _ -> pts_to r y)
= coerce_ghost (fun _ -> G.upd_gen r (raise_val x) (raise_val y) (UP.raise_frame_preserving_upd f))
/// Splits permission on reference [r], in a way that is compatible with the governing PCM.
let share (#o:inames)
(#a:Type)
(#p:pcm a)
(r:ref a p)
(v:a)
(v0:a)
(v1:a)
: STGhost unit o
(pts_to r v)
(fun _ -> pts_to r v0 `star` pts_to r v1)
(requires
composable p v0 v1 /\
v == op p v0 v1)
(ensures fun _ -> True)
= coerce_ghost (fun _ -> G.share r (raise_val v) (raise_val v0) (raise_val v1)) | {
"checked_file": "/",
"dependencies": [
"Steel.ST.Util.fsti.checked",
"Steel.ST.Coercions.fsti.checked",
"Steel.GhostPCMReference.fsti.checked",
"prims.fst.checked",
"FStar.Universe.PCM.fst.checked",
"FStar.Universe.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.ST.GhostPCMReference.fst"
} | [
{
"abbrev": true,
"full_module": "Steel.GhostPCMReference",
"short_module": "G"
},
{
"abbrev": true,
"full_module": "FStar.Universe.PCM",
"short_module": "UP"
},
{
"abbrev": false,
"full_module": "FStar.Universe",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Coercions",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.ST",
"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.ST.GhostPCMReference.ref a p -> v0: a -> v1: a
-> Steel.ST.Effect.Ghost.STGhostT (_: Prims.unit{FStar.PCM.composable p v0 v1}) | Steel.ST.Effect.Ghost.STGhostT | [] | [] | [
"Steel.Memory.inames",
"FStar.PCM.pcm",
"Steel.ST.GhostPCMReference.ref",
"Prims.unit",
"FStar.PCM.composable",
"FStar.Universe.raise_t",
"FStar.Universe.PCM.raise",
"FStar.Universe.raise_val",
"Steel.ST.Coercions.coerce_ghost",
"Steel.Effect.Common.star",
"Steel.GhostPCMReference.pts_to",
"FStar.PCM.op",
"Steel.Effect.Common.vprop",
"Prims.l_True",
"Steel.GhostPCMReference.gather",
"Steel.ST.GhostPCMReference.pts_to"
] | [] | false | true | false | false | false | let gather (#o: inames) (#a: Type) (#p: FStar.PCM.pcm a) (r: ref a p) (v0 v1: a)
: STGhostT (_: unit{composable p v0 v1})
o
((pts_to r v0) `star` (pts_to r v1))
(fun _ -> pts_to r (op p v0 v1)) =
| let _ = coerce_ghost (fun _ -> G.gather r (raise_val v0) (raise_val v1)) in
() | false |
Vale.Test.X64.Args.fst | Vale.Test.X64.Args.va_codegen_success_Test | val va_codegen_success_Test : win:bool -> Tot va_pbool | val va_codegen_success_Test : win:bool -> Tot va_pbool | let va_codegen_success_Test win =
(va_pbool_and (va_codegen_success_CreateHeaplets ()) (va_pbool_and (va_codegen_success_Mov64
(va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx)) (va_pbool_and
(va_codegen_success_DestroyHeaplets ()) (va_ttrue ())))) | {
"file_name": "obj/Vale.Test.X64.Args.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 60,
"end_line": 25,
"start_col": 0,
"start_line": 22
} | module Vale.Test.X64.Args
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Test
[@ "opaque_to_smt" va_qattr]
let va_code_Test win =
(va_Block (va_CCons (va_code_CreateHeaplets ()) (va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64
rRax) (va_op_opr64_reg64 rRbx)) (va_CCons (va_code_DestroyHeaplets ()) (va_CNil ()))))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Test.X64.Args.fst"
} | [
{
"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.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.Stack_i",
"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.Arch.HeapImpl",
"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.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.Stack_i",
"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.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.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.InsMem.va_codegen_success_CreateHeaplets",
"Vale.X64.InsBasic.va_codegen_success_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.InsMem.va_codegen_success_DestroyHeaplets",
"Vale.X64.Decls.va_ttrue",
"Vale.X64.Decls.va_pbool"
] | [] | false | false | false | true | false | let va_codegen_success_Test win =
| (va_pbool_and (va_codegen_success_CreateHeaplets ())
(va_pbool_and (va_codegen_success_Mov64 (va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx))
(va_pbool_and (va_codegen_success_DestroyHeaplets ()) (va_ttrue ())))) | false |
Pulse.Common.fst | Pulse.Common.lemma_map_dec_len | val lemma_map_dec_len (#a #b #z: _) (top: z) (f: (x: a{x << top} -> b)) (xs: list a {xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs)) [SMTPat (map_dec top xs f)] | val lemma_map_dec_len (#a #b #z: _) (top: z) (f: (x: a{x << top} -> b)) (xs: list a {xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs)) [SMTPat (map_dec top xs f)] | let rec lemma_map_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> b) (xs : list a{xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs))
[SMTPat (map_dec top xs f)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_dec_len top f xs | {
"file_name": "lib/steel/pulse/Pulse.Common.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 41,
"end_line": 130,
"start_col": 0,
"start_line": 125
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to 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 Pulse.Common
module L = FStar.List.Tot
open FStar.Tactics
let (let?) (f:option 'a) (g:'a -> option 'b) : option 'b =
match f with
| None -> None
| Some x -> g x
// let lem_bind_opt_some (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires Some? ((let?) x f))
// (ensures Some? x /\ Some? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
// let lem_bind_opt_none (x : option 'a) (f : 'a -> option 'b)
// : Lemma (requires None? ((let?) x f))
// (ensures None? x \/ None? (f (Some?.v x)))
// [SMTPat (Some? ((let?) x f))]
// = ()
let rec for_all_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> bool)) : bool =
match l with
| [] -> true
| x::xs -> f x && for_all_dec top xs f
let rec map_dec (top:'a) (l : list 'b{l << top}) (f : (x:'b{x << l} -> 'c)) : list 'c =
match l with
| [] -> []
| x::xs -> f x :: map_dec top xs f
let rec zipWith (f : 'a -> 'b -> Tac 'c) (l : list 'a) (m : list 'b)
: Tac (l':(list 'c){L.length l' == min (L.length l) (L.length m)})
=
match l, m with
| [], [] -> []
| x::xs, y::ys -> f x y :: zipWith f xs ys
| _ -> fail "zipWith: length mismatch"
val zip : (#a:Type) -> (#b:Type) -> l1:list a -> l2:list b ->
Tot (l:list (a * b){L.length l == min (L.length l1) (L.length l2)})
let rec zip #a #b l1 l2 = match l1, l2 with
| x::xs, y::ys -> (x,y) :: (zip xs ys)
| _ -> []
let rec map_opt f l = match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt f xs in
Some (y::ys)
let rec map_opt_dec #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (l : list a{l << top}) : option (list b)
= match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = map_opt_dec top f xs in
Some (y::ys)
let rec concat_map_opt #a #b (f : a -> option (list b)) (l : list a) : option (list b) =
match l with
| [] -> Some []
| x::xs ->
let? y = f x in
let? ys = concat_map_opt f xs in
Some (y@ys)
let rec lemma_map_opt_dec_len #a #b #z (top:z) (f : (x:a{x << top}) -> option b) (xs : list a{xs << top})
: Lemma (requires (Some? (map_opt_dec top f xs)))
(ensures (L.length (Some?.v (map_opt_dec top f xs)) == L.length xs))
[SMTPat (map_opt_dec top f xs)]
= match xs with
| [] -> ()
| x::xs -> lemma_map_opt_dec_len top f xs
// let rec __lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b) (i:nat{i < L.length xs})
// : Lemma (requires map_opt f xs == Some ys)
// (ensures f (xs `L.index` i) == Some (ys `L.index` i))
// = match xs, ys, i with
// | _, _, 0 -> ()
// | x::xs, y::ys, _ ->
// __lemma_map_opt_index f xs ys (i-1)
// let lemma_map_opt_index (f : 'a -> option 'b) (xs : list 'a) (ys : list 'b)
// : Lemma (requires map_opt f xs == Some ys)
// (ensures forall i. f (xs `L.index` i) == Some (ys `L.index` i))
// = Classical.forall_intro (Classical.move_requires (__lemma_map_opt_index f xs ys))
let rec dec_index #a (top:'z) (l : list a{l << top}) (i : nat{i < L.length l})
: Lemma (l `L.index` i << top)
[SMTPat (l `L.index` i << top)]
= match l, i with
| _, 0 -> ()
| _::l, _ -> dec_index top l (i-1) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Pulse.Common.fst"
} | [
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Pulse",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse",
"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 | top: z -> f: (x: a{x << top} -> b) -> xs: Prims.list a {xs << top}
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.length (Pulse.Common.map_dec top xs f) == FStar.List.Tot.Base.length xs)
[SMTPat (Pulse.Common.map_dec top xs f)] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.precedes",
"Prims.list",
"Pulse.Common.lemma_map_dec_len",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"FStar.List.Tot.Base.length",
"Pulse.Common.map_dec",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [
"recursion"
] | false | false | true | false | false | let rec lemma_map_dec_len #a #b #z (top: z) (f: (x: a{x << top} -> b)) (xs: list a {xs << top})
: Lemma (ensures (L.length (map_dec top xs f) == L.length xs)) [SMTPat (map_dec top xs f)] =
| match xs with
| [] -> ()
| x :: xs -> lemma_map_dec_len top f xs | false |
Hacl.Spec.Bignum.Convert.fst | Hacl.Spec.Bignum.Convert.bn_to_bytes_be_lemma | val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b)) | val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b)) | let bn_to_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i:nat{i < len}) :
Lemma (index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i == index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
() in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Convert.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 363,
"start_col": 0,
"start_line": 339
} | module Hacl.Spec.Bignum.Convert
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open Hacl.Spec.Bignum.Definitions
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_from_uint: #t:limb_t -> len:size_pos -> x:limb t -> lbignum t len
let bn_from_uint #t len x =
let b = create len (uint #t 0) in
b.[0] <- x
val bn_from_uint_lemma: #t:limb_t -> len:size_pos -> x:limb t ->
Lemma (bn_v (bn_from_uint len x) == uint_v x)
let bn_from_uint_lemma #t len x =
let b = create len (uint #t 0) in
let b = b.[0] <- x in
bn_eval_split_i b 1;
assert (bn_v b == bn_v (slice b 0 1) + pow2 (bits t) * bn_v (slice b 1 len));
eq_intro (slice b 1 len) (create (len - 1) (uint #t 0));
bn_eval_zeroes #t (len - 1) (len - 1);
assert (bn_v b == bn_v (slice b 0 1));
bn_eval1 (slice b 0 1)
val bn_from_bytes_be_f:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len)
-> i:nat{i < len} ->
limb t
let bn_from_bytes_be_f #t len b i =
uint_from_bytes_be (sub b ((len - i - 1) * numbytes t) (numbytes t))
val bn_from_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lseq uint8 (numbytes t * len) ->
lbignum t len
let bn_from_bytes_be_ #t len b =
createi len (bn_from_bytes_be_f len b)
val bn_from_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
bn_from_bytes_be_ bnLen tmp
val bn_from_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lseq uint8 len ->
lbignum t (blocks len (numbytes t))
let bn_from_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp 0 len b in
uints_from_bytes_le tmp
val bn_to_bytes_be_f:
#t:limb_t
-> len:size_nat
-> lbignum t len
-> i:nat{i < len}
-> unit ->
unit & lseq uint8 (numbytes t)
let bn_to_bytes_be_f #t len b i () =
(), uint_to_bytes_be b.[len - i - 1]
val bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> lbignum t len ->
lseq uint8 (numbytes t * len)
let bn_to_bytes_be_ #t len b =
let a_spec (i:nat{i <= len}) = unit in
let _, o = generate_blocks (numbytes t) len len a_spec
(bn_to_bytes_be_f len b) () in
o
val bn_to_bytes_be:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_be #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
sub tmp (tmpLen - len) len
val bn_to_bytes_le:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> lbignum t (blocks len (numbytes t)) ->
lseq uint8 len
let bn_to_bytes_le #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = uints_to_bytes_le b in
sub tmp 0 len
///
/// Lemmas
///
val reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> lbignum t len
let reverse #t #len b = createi len (fun i -> b.[len - i - 1])
val twice_reverse: #t:limb_t -> #len:size_nat -> b:lbignum t len -> Lemma (reverse (reverse b) == b)
let twice_reverse #t #len b =
let lemma_aux (i:nat{i < len}) : Lemma ((reverse (reverse b)).[i] == b.[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (reverse (reverse b)) b
val reverse_slice1: #t:limb_t -> #len:size_pos -> b:lbignum t len ->
Lemma (slice (reverse b) 1 len == reverse (slice b 0 (len - 1)))
let reverse_slice1 #t #len b =
let lemma_aux (i:nat{i < len - 1}) :
Lemma ((slice (reverse b) 1 len).[i] == (reverse (slice b 0 (len - 1))).[i]) = () in
Classical.forall_intro lemma_aux;
eq_intro (slice (reverse b) 1 len) (reverse (slice b 0 (len - 1)))
val bn_from_bytes_be_is_uints_from_bytes_be_reverse:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_from_bytes_be_ len b == reverse (uints_from_bytes_be b))
let bn_from_bytes_be_is_uints_from_bytes_be_reverse #t len b =
let lemma_aux (i:nat{i < len}) :
Lemma ((bn_from_bytes_be_ len b).[i] == (reverse #t #len (uints_from_bytes_be b)).[i])
=
index_uints_from_bytes_be #t #SEC #len b (len - i - 1) in
Classical.forall_intro lemma_aux;
eq_intro (bn_from_bytes_be_ len b) (reverse (uints_from_bytes_be b))
val bn_v_is_nat_from_intseq_be_lemma: #t:limb_t -> len:size_nat -> b:lbignum t len ->
Lemma (bn_v b == nat_from_intseq_be (reverse b))
let rec bn_v_is_nat_from_intseq_be_lemma #t len b =
if len = 0 then bn_eval0 b
else begin
let b1 = slice b 0 (len - 1) in
bn_v_is_nat_from_intseq_be_lemma (len - 1) b1;
assert (bn_v b1 == nat_from_intseq_be (reverse b1));
bn_eval_split_i #t #len b (len - 1);
bn_eval_unfold_i #t #1 (slice b (len - 1) len) 1;
bn_eval0 #t #1 (slice b (len - 1) len);
assert (bn_v (slice b (len - 1) len) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b1) + pow2 (bits t * (len - 1)) * v b.[len - 1]);
nat_from_intseq_be_slice_lemma (reverse b) 1;
reverse_slice1 #t #len b;
assert ((reverse b).[0] == b.[len - 1]);
nat_from_intseq_be_lemma0 (slice (reverse b) 0 1);
assert (nat_from_intseq_be (slice (reverse b) 0 1) == v b.[len - 1]);
assert (bn_v b == nat_from_intseq_be (reverse b));
() end
val bn_from_bytes_be_lemma_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lseq uint8 (numbytes t * len) ->
Lemma (bn_v (bn_from_bytes_be_ len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma_ #t len b =
bn_v_is_nat_from_intseq_be_lemma len (bn_from_bytes_be_ len b);
bn_from_bytes_be_is_uints_from_bytes_be_reverse len b;
twice_reverse (uints_from_bytes_be #t #SEC #len b);
assert (bn_v (bn_from_bytes_be_ len b) == nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b));
uints_from_bytes_be_nat_lemma #t #SEC #len b;
assert (nat_from_intseq_be (uints_from_bytes_be #t #SEC #len b) == nat_from_bytes_be b)
val lemma_nat_from_bytes_be_zeroes: len:size_nat -> b:lseq uint8 len -> Lemma
(requires (forall (i:nat). i < len ==> b.[i] == u8 0))
(ensures nat_from_intseq_be b == 0)
let rec lemma_nat_from_bytes_be_zeroes len b =
if len = 0 then ()
else begin
nat_from_intseq_be_slice_lemma #U8 #SEC #len b 1;
nat_from_intseq_be_lemma0 (slice b 0 1);
lemma_nat_from_bytes_be_zeroes (len-1) (slice b 1 len) end
val nat_from_bytes_be_eq_lemma: len0:size_nat -> len:size_nat{len0 <= len} -> b:lseq uint8 len0 ->
Lemma (let tmp = create len (u8 0) in
nat_from_intseq_be b == nat_from_intseq_be (update_sub tmp (len - len0) len0 b))
let nat_from_bytes_be_eq_lemma len0 len b =
let tmp = create len (u8 0) in
let r = update_sub tmp (len - len0) len0 b in
assert (slice r (len - len0) len == b);
assert (forall (i:nat). i < len - len0 ==> r.[i] == u8 0);
nat_from_intseq_be_slice_lemma #U8 #SEC #len r (len - len0);
assert (nat_from_intseq_be r == nat_from_intseq_be (slice r (len - len0) len) + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
assert (nat_from_intseq_be r == nat_from_intseq_be b + pow2 (len0 * 8) * nat_from_intseq_be (Seq.slice r 0 (len - len0)));
lemma_nat_from_bytes_be_zeroes (len - len0) (Seq.slice r 0 (len - len0))
val bn_from_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lseq uint8 len ->
Lemma (bn_v (bn_from_bytes_be #t len b) == nat_from_bytes_be b)
let bn_from_bytes_be_lemma #t len b =
let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = create tmpLen (u8 0) in
let tmp = update_sub tmp (tmpLen - len) len b in
let res = bn_from_bytes_be_ #t bnLen tmp in
bn_from_bytes_be_lemma_ #t bnLen tmp;
assert (bn_v (bn_from_bytes_be_ #t bnLen tmp) == nat_from_bytes_be tmp);
nat_from_bytes_be_eq_lemma len tmpLen b
val index_bn_to_bytes_be_:
#t:limb_t
-> len:size_nat{numbytes t * len <= max_size_t}
-> b:lbignum t len
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
(bn_to_bytes_be_ #t len b).[i] ==
uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
let index_bn_to_bytes_be_ #t len b i =
let numb = numbytes t in
let bi = b.[len - i / numb - 1] in
index_generate_blocks (numb) len len (bn_to_bytes_be_f len b) i;
assert ((bn_to_bytes_be_ #t len b).[i] == (uint_to_bytes_be bi).[i % numb]);
index_uint_to_bytes_be bi;
assert ((uint_to_bytes_be bi).[i % numb] == uint #U8 #SEC (v bi / pow2 (8 * (numb - 1 - i % numb)) % pow2 8))
val bn_to_bytes_be_lemma_aux:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)}
-> i:nat{i < numbytes t * len} ->
Lemma (let numb = numbytes t in
bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8 ==
v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8)
let bn_to_bytes_be_lemma_aux #t len b i =
let pbits = bits t in
let numb = numbytes t in
let e = numb - 1 - i % numb in
let e1 = len - i / numb - 1 in
let e2 = numb * len - 1 - i in
calc (==) {
v b.[e1] / pow2 (8 * e) % pow2 8;
(==) { bn_eval_index b e1 }
(bn_v b / pow2 (pbits * e1) % pow2 (pbits)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (pbits * e1) (pbits + pbits * e1) }
(bn_v b % pow2 (pbits + pbits * e1) / pow2 (pbits * e1)) / pow2 (8 * e) % pow2 8;
(==) { Math.Lemmas.division_multiplication_lemma (bn_v b % pow2 (pbits + pbits * e1)) (pow2 (pbits * e1)) (pow2 (8 * e)) }
(bn_v b % pow2 (pbits + pbits * e1)) / (pow2 (pbits * e1) * pow2 (8 * e)) % pow2 8;
(==) { Math.Lemmas.pow2_plus (pbits * e1) (8 * e) }
(bn_v b % pow2 (pbits + pbits * e1)) / pow2 (pbits * e1 + 8 * e) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_division_lemma_1 (bn_v b) (8 * e2) (pbits + pbits * e1) }
(bn_v b / pow2 (8 * e2)) % pow2 (pbits + pbits * e1 - 8 * e2) % pow2 8;
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 (bn_v b / pow2 (8 * e2)) 8 (pbits + pbits * e1 - 8 * e2) }
(bn_v b / pow2 (8 * (numb * len - i - 1))) % pow2 8;
}
val bn_to_bytes_be_lemma_:
#t:limb_t
-> len:size_pos{numbytes t * len <= max_size_t}
-> b:lbignum t len{bn_v b < pow2 (bits t * len)} ->
Lemma (bn_to_bytes_be_ #t len b == nat_to_intseq_be #U8 #SEC (numbytes t * len) (bn_v b))
let bn_to_bytes_be_lemma_ #t len b =
let numb = numbytes t in
let lemma_aux (i:nat{i < numb * len}) :
Lemma ((bn_to_bytes_be_ #t len b).[i] == index #uint8 #(numb * len) (nat_to_intseq_be (numb * len) (bn_v b)) i)
=
let rp = nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) in
index_nat_to_intseq_be #U8 #SEC (numb * len) (bn_v b) (numb * len - i - 1);
assert (index #uint8 #(numb * len) rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (numb * len - i - 1)) % pow2 8));
index_bn_to_bytes_be_ len b i;
assert ((bn_to_bytes_be_ #t len b).[i] == uint #U8 #SEC (v b.[len - i / numb - 1] / pow2 (8 * (numb - 1 - i % numb)) % pow2 8));
bn_to_bytes_be_lemma_aux len b i;
() in
Classical.forall_intro lemma_aux;
eq_intro (bn_to_bytes_be_ len b) (nat_to_intseq_be (numb * len) (bn_v b))
val bn_to_bytes_be_lemma:
#t:limb_t
-> len:size_pos{numbytes t * blocks len (numbytes t) <= max_size_t}
-> b:lbignum t (blocks len (numbytes t)){bn_v b < pow2 (8 * len)} ->
Lemma (bn_to_bytes_be #t len b == nat_to_intseq_be #U8 #SEC len (bn_v b)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Convert.fst"
} | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"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": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.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 |
len:
Lib.IntTypes.size_pos
{ Lib.IntTypes.numbytes t *
Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t) <=
Lib.IntTypes.max_size_t } ->
b:
Hacl.Spec.Bignum.Definitions.lbignum t
(Hacl.Spec.Bignum.Definitions.blocks len (Lib.IntTypes.numbytes t))
{Hacl.Spec.Bignum.Definitions.bn_v b < Prims.pow2 (8 * len)}
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Convert.bn_to_bytes_be len b ==
Lib.ByteSequence.nat_to_intseq_be len (Hacl.Spec.Bignum.Definitions.bn_v b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star",
"Lib.IntTypes.numbytes",
"Hacl.Spec.Bignum.Definitions.blocks",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.pow2",
"Lib.Sequence.eq_intro",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.nat_to_intseq_be",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Lib.IntTypes.uint8",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.sub",
"Prims.op_Subtraction",
"Lib.Sequence.index",
"Prims.l_True",
"Prims.squash",
"Lib.IntTypes.int_t",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims._assert",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.v",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Addition",
"Lib.IntTypes.uint",
"Lib.ByteSequence.index_nat_to_intseq_be",
"Lib.Sequence.seq",
"Prims.l_and",
"Lib.Sequence.length",
"Prims.op_Multiply",
"Lib.ByteSequence.nat_from_intseq_be",
"FStar.Seq.Base.length",
"Lib.IntTypes.bits",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_lemma_",
"FStar.Math.Lemmas.pow2_le_compat",
"Lib.Sequence.lseq",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Prims.l_Forall",
"Hacl.Spec.Bignum.Convert.bn_to_bytes_be_",
"Prims.pos"
] | [] | false | false | true | false | false | let bn_to_bytes_be_lemma #t len b =
| let bnLen = blocks len (numbytes t) in
let tmpLen = numbytes t * bnLen in
let tmp = bn_to_bytes_be_ bnLen b in
let res = sub tmp (tmpLen - len) len in
assert (bn_v b < pow2 (8 * len));
Math.Lemmas.pow2_le_compat (bits t * bnLen) (8 * len);
assert (bn_v b < pow2 (bits t * bnLen));
bn_to_bytes_be_lemma_ bnLen b;
assert (tmp == nat_to_intseq_be #U8 #SEC tmpLen (bn_v b));
let lemma_aux (i: nat{i < len})
: Lemma
(index (sub #uint8 #tmpLen (nat_to_intseq_be #U8 #SEC tmpLen (bn_v b)) (tmpLen - len) len) i ==
index #uint8 #len (nat_to_intseq_be #U8 #SEC len (bn_v b)) i) =
let rp = nat_to_intseq_be #U8 #SEC len (bn_v b) in
index_nat_to_intseq_be #U8 #SEC len (bn_v b) (len - i - 1);
assert (index #uint8 #len rp i == uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
let lp = nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) in
assert (index (sub #uint8 #tmpLen lp (tmpLen - len) len) i ==
index #uint8 #tmpLen lp (tmpLen - len + i));
index_nat_to_intseq_be #U8 #SEC tmpLen (bn_v b) (len - i - 1);
assert (index #uint8 #tmpLen lp (tmpLen - len + i) ==
uint #U8 #SEC (bn_v b / pow2 (8 * (len - i - 1)) % pow2 8));
()
in
Classical.forall_intro lemma_aux;
eq_intro (nat_to_intseq_be #U8 #SEC len (bn_v b)) res | false |
Vale.Test.X64.Args.fst | Vale.Test.X64.Args.va_code_Test | val va_code_Test : win:bool -> Tot va_code | val va_code_Test : win:bool -> Tot va_code | let va_code_Test win =
(va_Block (va_CCons (va_code_CreateHeaplets ()) (va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64
rRax) (va_op_opr64_reg64 rRbx)) (va_CCons (va_code_DestroyHeaplets ()) (va_CNil ()))))) | {
"file_name": "obj/Vale.Test.X64.Args.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 91,
"end_line": 19,
"start_col": 0,
"start_line": 17
} | module Vale.Test.X64.Args
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Test | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Test.X64.Args.fst"
} | [
{
"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.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.Stack_i",
"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.Arch.HeapImpl",
"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.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.Stack_i",
"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.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.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.InsMem.va_code_CreateHeaplets",
"Vale.X64.InsBasic.va_code_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.InsMem.va_code_DestroyHeaplets",
"Vale.X64.Decls.va_CNil",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_Test win =
| (va_Block (va_CCons (va_code_CreateHeaplets ())
(va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx))
(va_CCons (va_code_DestroyHeaplets ()) (va_CNil ()))))) | false |
Vale.Test.X64.Args.fst | Vale.Test.X64.Args.va_qcode_Test | val va_qcode_Test
(va_mods: va_mods_t)
(win: bool)
(arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7: buffer64)
: (va_quickCode unit (va_code_Test win)) | val va_qcode_Test
(va_mods: va_mods_t)
(win: bool)
(arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7: buffer64)
: (va_quickCode unit (va_code_Test win)) | let va_qcode_Test (va_mods:va_mods_t) (win:bool) (arg0:buffer64) (arg1:buffer64) (arg2:buffer64)
(arg3:buffer64) (arg4:buffer64) (arg5:buffer64) (arg6:buffer64) (arg7:buffer64) : (va_quickCode
unit (va_code_Test win)) =
(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 79 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_CreateHeaplets ([declare_buffer64 arg0 0 Secret Immutable; declare_buffer64 arg1 0
Secret Immutable; declare_buffer64 arg2 0 Secret Immutable; declare_buffer64 arg3 0 Secret
Immutable; declare_buffer64 arg4 0 Secret Immutable; declare_buffer64 arg5 0 Secret Immutable;
declare_buffer64 arg6 0 Secret Immutable; declare_buffer64 arg7 0 Secret Immutable])) (va_QSeq
va_range1
"***** PRECONDITION NOT MET AT line 89 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx)) (va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 91 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_DestroyHeaplets ()) (va_QEmpty (())))))) | {
"file_name": "obj/Vale.Test.X64.Args.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 41,
"start_col": 0,
"start_line": 28
} | module Vale.Test.X64.Args
open Vale.Arch.HeapImpl
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.Stack_i
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
#set-options "--z3rlimit 20"
//-- Test
[@ "opaque_to_smt" va_qattr]
let va_code_Test win =
(va_Block (va_CCons (va_code_CreateHeaplets ()) (va_CCons (va_code_Mov64 (va_op_dst_opr64_reg64
rRax) (va_op_opr64_reg64 rRbx)) (va_CCons (va_code_DestroyHeaplets ()) (va_CNil ())))))
[@ "opaque_to_smt" va_qattr]
let va_codegen_success_Test win =
(va_pbool_and (va_codegen_success_CreateHeaplets ()) (va_pbool_and (va_codegen_success_Mov64
(va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx)) (va_pbool_and
(va_codegen_success_DestroyHeaplets ()) (va_ttrue ())))) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.Stack_i.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.Decls.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.Test.X64.Args.fst"
} | [
{
"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.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.Stack_i",
"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.Arch.HeapImpl",
"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.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.Stack_i",
"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.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Test.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 ->
win: Prims.bool ->
arg0: Vale.X64.Memory.buffer64 ->
arg1: Vale.X64.Memory.buffer64 ->
arg2: Vale.X64.Memory.buffer64 ->
arg3: Vale.X64.Memory.buffer64 ->
arg4: Vale.X64.Memory.buffer64 ->
arg5: Vale.X64.Memory.buffer64 ->
arg6: Vale.X64.Memory.buffer64 ->
arg7: Vale.X64.Memory.buffer64
-> Vale.X64.QuickCode.va_quickCode Prims.unit (Vale.Test.X64.Args.va_code_Test win) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.va_mods_t",
"Prims.bool",
"Vale.X64.Memory.buffer64",
"Vale.X64.QuickCodes.qblock",
"Prims.unit",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.InsMem.va_code_CreateHeaplets",
"Vale.X64.InsBasic.va_code_Mov64",
"Vale.X64.Decls.va_op_dst_opr64_reg64",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_op_opr64_reg64",
"Vale.X64.Machine_s.rRbx",
"Vale.X64.InsMem.va_code_DestroyHeaplets",
"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.InsMem.va_quick_CreateHeaplets",
"Vale.Arch.HeapImpl.buffer_info",
"Vale.X64.InsMem.declare_buffer64",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.Arch.HeapImpl.Immutable",
"Vale.X64.InsBasic.va_quick_Mov64",
"Vale.X64.InsMem.va_quick_DestroyHeaplets",
"Vale.X64.QuickCodes.va_QEmpty",
"Vale.X64.State.vale_state",
"Vale.X64.QuickCodes.quickCodes",
"Vale.X64.QuickCode.va_quickCode",
"Vale.Test.X64.Args.va_code_Test"
] | [] | false | false | false | false | false | let va_qcode_Test
(va_mods: va_mods_t)
(win: bool)
(arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7: buffer64)
: (va_quickCode unit (va_code_Test win)) =
| (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 79 column 19 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_CreateHeaplets ([
declare_buffer64 arg0 0 Secret Immutable;
declare_buffer64 arg1 0 Secret Immutable;
declare_buffer64 arg2 0 Secret Immutable;
declare_buffer64 arg3 0 Secret Immutable;
declare_buffer64 arg4 0 Secret Immutable;
declare_buffer64 arg5 0 Secret Immutable;
declare_buffer64 arg6 0 Secret Immutable;
declare_buffer64 arg7 0 Secret Immutable
]))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 89 column 10 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_Mov64 (va_op_dst_opr64_reg64 rRax) (va_op_opr64_reg64 rRbx))
(va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 91 column 20 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/test/Vale.Test.X64.Args.vaf *****"
(va_quick_DestroyHeaplets ())
(va_QEmpty (())))))) | false |
CQueue.fst | CQueue.squash | val squash (p: Type u#a) : Type0 | val squash (p: Type u#a) : Type0 | let squash (p:Type u#a) : Type0 = squash p | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 42,
"end_line": 11,
"start_col": 0,
"start_line": 11
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q} | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.fst"
} | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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.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: Type -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Prims.squash"
] | [] | false | false | false | true | true | let squash (p: Type u#a) : Type0 =
| squash p | false |
BitFields.fst | BitFields.rewrite_field | val rewrite_field (env: B.global_env) (f: field) : ML (f': field{field_tag_equal f f'}) | val rewrite_field (env: B.global_env) (f: field) : ML (f': field{field_tag_equal f f'}) | let rec rewrite_field (env:B.global_env) (f:field)
: ML (f':field {field_tag_equal f f'})
= match f.v with
| AtomicField _ -> f
| RecordField fs field_name ->
let gfs = group_bit_fields (rewrite_field env) fs in
let fs, subst =
List.fold_right
(fun f (fields, subst) ->
match f with
| Inl f -> (f::fields, subst)
| Inr gf ->
let f, subst' = coalesce_grouped_bit_field (B.mk_env env) gf in
f::fields, subst'@subst)
gfs
([], [])
in
let fs = List.map (subst_field (mk_subst subst)) fs in
{ f with v = RecordField fs field_name }
| SwitchCaseField (e, cases) field_name ->
let cases =
List.map
(function
| Case p f ->
Case p (rewrite_field env f)
| DefaultCase f ->
DefaultCase (rewrite_field env f))
cases
in
{ f with v = SwitchCaseField (e, cases) field_name } | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 58,
"end_line": 164,
"start_col": 0,
"start_line": 132
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*)
let bitfield_group = int & typ & list atomic_field
let grouped_fields = either field bitfield_group
let group_bit_fields (rewrite_composite_field: field -> ML field)
(fields: list field)
: ML (list grouped_fields)
= List.fold_right
(fun field out ->
match field.v with
| RecordField _ _
| SwitchCaseField _ _ ->
Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None ->
Inl field :: out
| Some (Inl _) ->
failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields)::tl ->
if index = bf.v.bitfield_identifier
then Inr(index, typ, af :: atomic_fields) :: tl //extend this bitfield group
else Inr(bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
)
fields
[]
let subst' = list (ident & expr)
let coalesce_grouped_bit_field env (f:bitfield_group)
: ML (field & subst')
= let id, typ, fields = f in
let size = B.size_of_integral_typ env typ typ.range in
let bitsize = 8 * size in
let order = B.bit_order_of_integral_typ env typ typ.range in
let field_id = with_range (to_ident' (Printf.sprintf "__bitfield_%d" id)) dummy_range in
let id = with_range (Identifier field_id) field_id.range in
let mk_e (e:expr') :expr = with_range e field_id.range in
let bitfield_attrs f : ML _ =
match f.field_bitwidth with
| Some (Inr bf) -> bf.v
| _ -> failwith "Must have elaborated bitfield"
in
let field_dependence, field_constraint, field_action, subst =
List.fold_left
(fun (acc:(bool & _ & option (action & bool) & _)) f ->
let (dep, acc_constraint, acc_action, subst) = acc in
let f = f.v in
let acc_action, acc_dep =
match acc_action, f.field_action with
| None, None
| Some _, None -> acc_action, false
| None, Some (_, d) -> f.field_action, d
| Some (acc, dep_0), Some (fa, dep_1) ->
if Action_act? acc.v
&& Action_act? fa.v
then
Some (Ast.sequence_non_failing_actions acc fa, dep_0 || dep_1),
dep_0 || dep_1
else
failwith "Multiple, potentially failing actions are not supported on bitfields"
in
let dep = dep || acc_dep || f.field_dependence in
let acc_constraint =
match f.field_constraint, acc_constraint with
| None, _ -> acc_constraint
| Some _, None -> f.field_constraint
| Some c, Some acc -> Some (mk_e (App And [acc; c]))
in
let bf_exp =
App
(BitFieldOf bitsize order)
[id;
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_from));
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_to))]
in
let subst = (f.field_ident, mk_e bf_exp) :: subst in
dep, acc_constraint, acc_action, subst)
(false, None, None, [])
fields
in
let struct_field = {
field_dependence = field_dependence;
field_ident = field_id;
field_type = typ;
field_array_opt = FieldScalar;
field_constraint = field_constraint;
field_bitwidth = None;
field_action = field_action;
field_probe = None
} in
let af = with_dummy_range struct_field in
with_dummy_range (AtomicField af),
subst | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | env: GlobalEnv.global_env -> f: Ast.field -> FStar.All.ML (f': Ast.field{Ast.field_tag_equal f f'}) | FStar.All.ML | [
"ml"
] | [] | [
"GlobalEnv.global_env",
"Ast.field",
"Ast.__proj__Mkwith_meta_t__item__v",
"Ast.field'",
"Ast.with_meta_t",
"Ast.atomic_field'",
"Prims.b2t",
"Ast.field_tag_equal",
"Prims.list",
"Ast.ident",
"FStar.Pervasives.Native.tuple2",
"Ast.expr",
"Ast.Mkwith_meta_t",
"Ast.RecordField",
"Ast.__proj__Mkwith_meta_t__item__range",
"Ast.__proj__Mkwith_meta_t__item__comments",
"FStar.List.map",
"Ast.subst_field",
"Ast.subst",
"Ast.mk_subst",
"FStar.List.fold_right",
"Ast.either",
"BitFields.bitfield_group",
"FStar.Pervasives.Native.Mktuple2",
"Prims.Cons",
"BitFields.subst'",
"FStar.List.Tot.Base.op_At",
"BitFields.coalesce_grouped_bit_field",
"Binding.env",
"Binding.mk_env",
"Prims.Nil",
"BitFields.grouped_fields",
"BitFields.group_bit_fields",
"BitFields.rewrite_field",
"Ast.case",
"Ast.SwitchCaseField",
"Ast.Case",
"Ast.DefaultCase"
] | [
"recursion"
] | false | true | false | false | false | let rec rewrite_field (env: B.global_env) (f: field) : ML (f': field{field_tag_equal f f'}) =
| match f.v with
| AtomicField _ -> f
| RecordField fs field_name ->
let gfs = group_bit_fields (rewrite_field env) fs in
let fs, subst =
List.fold_right (fun f (fields, subst) ->
match f with
| Inl f -> (f :: fields, subst)
| Inr gf ->
let f, subst' = coalesce_grouped_bit_field (B.mk_env env) gf in
f :: fields, subst' @ subst)
gfs
([], [])
in
let fs = List.map (subst_field (mk_subst subst)) fs in
{ f with v = RecordField fs field_name }
| SwitchCaseField (e, cases) field_name ->
let cases =
List.map (function
| Case p f -> Case p (rewrite_field env f)
| DefaultCase f -> DefaultCase (rewrite_field env f))
cases
in
{ f with v = SwitchCaseField (e, cases) field_name } | false |
CQueue.fst | CQueue.vpure | val vpure (p: prop) : Tot vprop | val vpure (p: prop) : Tot vprop | let vpure (p: prop) : Tot vprop = VUnit (vpure' p) | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 50,
"end_line": 105,
"start_col": 0,
"start_line": 105
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (p:Type u#a) : Type0 = squash p
(* BEGIN library *)
let intro_vrewrite_no_norm (#opened:inames)
(v: vprop) (#t: Type) (f: (t_of v) -> GTot t)
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v))
=
intro_vrewrite v f
let elim_vrewrite_no_norm (#opened:inames)
(v: vprop)
(#t: Type)
(f: ((t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v))
=
elim_vrewrite v f
let vconst_sel
(#a: Type)
(x: a)
: Tot (selector a (hp_of emp))
= fun _ -> x
[@@ __steel_reduce__]
let vconst'
(#a: Type)
(x: a)
: GTot vprop'
= {
hp = hp_of emp;
t = a;
sel = vconst_sel x;
}
[@@ __steel_reduce__]
let vconst (#a: Type) (x: a) : Tot vprop = VUnit (vconst' x)
let intro_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
emp
(fun _ -> vconst x)
(fun _ -> True)
(fun _ _ h' -> h' (vconst x) == x)
=
change_slprop_rel
emp
(vconst x)
(fun _ y -> y == x)
(fun _ -> ())
let elim_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
(vconst x)
(fun _ -> emp)
(fun _ -> True)
(fun h _ _ -> h (vconst x) == x)
=
change_slprop_rel
(vconst x)
emp
(fun y _ -> y == x)
(fun _ -> ())
let vpure_sel'
(p: prop)
: Tot (selector' (squash p) (Steel.Memory.pure p))
= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
let vpure_sel
(p: prop)
: Tot (selector (squash p) (Steel.Memory.pure p))
= vpure_sel' p
[@@ __steel_reduce__]
let vpure'
(p: prop)
: GTot vprop'
= {
hp = Steel.Memory.pure p;
t = squash p;
sel = vpure_sel p;
} | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.fst"
} | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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.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: Prims.prop -> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Prims.prop",
"Steel.Effect.Common.VUnit",
"CQueue.vpure'",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | true | false | let vpure (p: prop) : Tot vprop =
| VUnit (vpure' p) | false |
CQueue.fst | CQueue.vpure' | val vpure' (p: prop) : GTot vprop' | val vpure' (p: prop) : GTot vprop' | let vpure'
(p: prop)
: GTot vprop'
= {
hp = Steel.Memory.pure p;
t = squash p;
sel = vpure_sel p;
} | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 1,
"end_line": 102,
"start_col": 0,
"start_line": 95
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (p:Type u#a) : Type0 = squash p
(* BEGIN library *)
let intro_vrewrite_no_norm (#opened:inames)
(v: vprop) (#t: Type) (f: (t_of v) -> GTot t)
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v))
=
intro_vrewrite v f
let elim_vrewrite_no_norm (#opened:inames)
(v: vprop)
(#t: Type)
(f: ((t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v))
=
elim_vrewrite v f
let vconst_sel
(#a: Type)
(x: a)
: Tot (selector a (hp_of emp))
= fun _ -> x
[@@ __steel_reduce__]
let vconst'
(#a: Type)
(x: a)
: GTot vprop'
= {
hp = hp_of emp;
t = a;
sel = vconst_sel x;
}
[@@ __steel_reduce__]
let vconst (#a: Type) (x: a) : Tot vprop = VUnit (vconst' x)
let intro_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
emp
(fun _ -> vconst x)
(fun _ -> True)
(fun _ _ h' -> h' (vconst x) == x)
=
change_slprop_rel
emp
(vconst x)
(fun _ y -> y == x)
(fun _ -> ())
let elim_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
(vconst x)
(fun _ -> emp)
(fun _ -> True)
(fun h _ _ -> h (vconst x) == x)
=
change_slprop_rel
(vconst x)
emp
(fun y _ -> y == x)
(fun _ -> ())
let vpure_sel'
(p: prop)
: Tot (selector' (squash p) (Steel.Memory.pure p))
= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
let vpure_sel
(p: prop)
: Tot (selector (squash p) (Steel.Memory.pure p))
= vpure_sel' p | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.fst"
} | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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.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: Prims.prop -> Prims.GTot Steel.Effect.Common.vprop' | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.prop",
"Steel.Effect.Common.Mkvprop'",
"Steel.Memory.pure",
"CQueue.squash",
"CQueue.vpure_sel",
"Steel.Effect.Common.vprop'"
] | [] | false | false | false | false | false | let vpure' (p: prop) : GTot vprop' =
| { hp = Steel.Memory.pure p; t = squash p; sel = vpure_sel p } | false |
BitFields.fst | BitFields.eliminate_one_decl | val eliminate_one_decl (env: B.global_env) (d: decl) : ML decl | val eliminate_one_decl (env: B.global_env) (d: decl) : ML decl | let eliminate_one_decl (env:B.global_env) (d:decl) : ML decl =
match d.d_decl.v with
| Record names params where fields ->
let i = with_dummy_range (to_ident' "_") in
let { v = RecordField fields _ } = rewrite_field env (with_dummy_range (RecordField fields i)) in
List.iter (fun f ->
Options.debug_print_string
(Printf.sprintf "Bitfields: Field %s has comments <%s>\n"
(print_field f)
(String.concat "\n" f.comments))) fields;
let fields =
match fields with
| [{v=AtomicField af; range; comments}] -> //just one field, it need no longer be dependent
let af' = { af.v with field_dependence = false } in
let af' = { af with v = af' } in
[{v=AtomicField af; range; comments}]
| _ -> fields
in
decl_with_v d (Record names params where fields)
| _ -> d | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 187,
"start_col": 0,
"start_line": 167
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*)
let bitfield_group = int & typ & list atomic_field
let grouped_fields = either field bitfield_group
let group_bit_fields (rewrite_composite_field: field -> ML field)
(fields: list field)
: ML (list grouped_fields)
= List.fold_right
(fun field out ->
match field.v with
| RecordField _ _
| SwitchCaseField _ _ ->
Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None ->
Inl field :: out
| Some (Inl _) ->
failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields)::tl ->
if index = bf.v.bitfield_identifier
then Inr(index, typ, af :: atomic_fields) :: tl //extend this bitfield group
else Inr(bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
)
fields
[]
let subst' = list (ident & expr)
let coalesce_grouped_bit_field env (f:bitfield_group)
: ML (field & subst')
= let id, typ, fields = f in
let size = B.size_of_integral_typ env typ typ.range in
let bitsize = 8 * size in
let order = B.bit_order_of_integral_typ env typ typ.range in
let field_id = with_range (to_ident' (Printf.sprintf "__bitfield_%d" id)) dummy_range in
let id = with_range (Identifier field_id) field_id.range in
let mk_e (e:expr') :expr = with_range e field_id.range in
let bitfield_attrs f : ML _ =
match f.field_bitwidth with
| Some (Inr bf) -> bf.v
| _ -> failwith "Must have elaborated bitfield"
in
let field_dependence, field_constraint, field_action, subst =
List.fold_left
(fun (acc:(bool & _ & option (action & bool) & _)) f ->
let (dep, acc_constraint, acc_action, subst) = acc in
let f = f.v in
let acc_action, acc_dep =
match acc_action, f.field_action with
| None, None
| Some _, None -> acc_action, false
| None, Some (_, d) -> f.field_action, d
| Some (acc, dep_0), Some (fa, dep_1) ->
if Action_act? acc.v
&& Action_act? fa.v
then
Some (Ast.sequence_non_failing_actions acc fa, dep_0 || dep_1),
dep_0 || dep_1
else
failwith "Multiple, potentially failing actions are not supported on bitfields"
in
let dep = dep || acc_dep || f.field_dependence in
let acc_constraint =
match f.field_constraint, acc_constraint with
| None, _ -> acc_constraint
| Some _, None -> f.field_constraint
| Some c, Some acc -> Some (mk_e (App And [acc; c]))
in
let bf_exp =
App
(BitFieldOf bitsize order)
[id;
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_from));
mk_e (Constant (Int UInt32 (bitfield_attrs f).bitfield_to))]
in
let subst = (f.field_ident, mk_e bf_exp) :: subst in
dep, acc_constraint, acc_action, subst)
(false, None, None, [])
fields
in
let struct_field = {
field_dependence = field_dependence;
field_ident = field_id;
field_type = typ;
field_array_opt = FieldScalar;
field_constraint = field_constraint;
field_bitwidth = None;
field_action = field_action;
field_probe = None
} in
let af = with_dummy_range struct_field in
with_dummy_range (AtomicField af),
subst
let rec rewrite_field (env:B.global_env) (f:field)
: ML (f':field {field_tag_equal f f'})
= match f.v with
| AtomicField _ -> f
| RecordField fs field_name ->
let gfs = group_bit_fields (rewrite_field env) fs in
let fs, subst =
List.fold_right
(fun f (fields, subst) ->
match f with
| Inl f -> (f::fields, subst)
| Inr gf ->
let f, subst' = coalesce_grouped_bit_field (B.mk_env env) gf in
f::fields, subst'@subst)
gfs
([], [])
in
let fs = List.map (subst_field (mk_subst subst)) fs in
{ f with v = RecordField fs field_name }
| SwitchCaseField (e, cases) field_name ->
let cases =
List.map
(function
| Case p f ->
Case p (rewrite_field env f)
| DefaultCase f ->
DefaultCase (rewrite_field env f))
cases
in
{ f with v = SwitchCaseField (e, cases) field_name } | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | env: GlobalEnv.global_env -> d: Ast.decl -> FStar.All.ML Ast.decl | FStar.All.ML | [
"ml"
] | [] | [
"GlobalEnv.global_env",
"Ast.decl",
"Ast.__proj__Mkwith_meta_t__item__v",
"Ast.decl'",
"Ast.__proj__Mkdecl__item__d_decl",
"Ast.typedef_names",
"Prims.list",
"Ast.param",
"FStar.Pervasives.Native.option",
"Ast.expr",
"Ast.record",
"Ast.with_meta_t",
"Ast.field'",
"Ast.ident",
"Ast.range",
"Ast.comments",
"Ast.decl_with_v",
"Ast.Record",
"Ast.atomic_field'",
"Prims.Cons",
"Ast.Mkwith_meta_t",
"Ast.AtomicField",
"Prims.Nil",
"Ast.__proj__Mkwith_meta_t__item__range",
"Ast.__proj__Mkwith_meta_t__item__comments",
"Ast.Mkatomic_field'",
"Ast.__proj__Mkatomic_field'__item__field_ident",
"Ast.__proj__Mkatomic_field'__item__field_type",
"Ast.__proj__Mkatomic_field'__item__field_array_opt",
"Ast.__proj__Mkatomic_field'__item__field_constraint",
"Ast.__proj__Mkatomic_field'__item__field_bitwidth",
"Ast.__proj__Mkatomic_field'__item__field_action",
"Ast.__proj__Mkatomic_field'__item__field_probe",
"Prims.unit",
"FStar.List.iter",
"Options.debug_print_string",
"Prims.string",
"FStar.String.concat",
"FStar.Printf.sprintf",
"Ast.print_field",
"Ast.field",
"Prims.b2t",
"Ast.field_tag_equal",
"Ast.with_dummy_range",
"Ast.RecordField",
"BitFields.rewrite_field",
"Ast.ident'",
"Ast.to_ident'"
] | [] | false | true | false | false | false | let eliminate_one_decl (env: B.global_env) (d: decl) : ML decl =
| match d.d_decl.v with
| Record names params where fields ->
let i = with_dummy_range (to_ident' "_") in
let { v = RecordField fields _ } = rewrite_field env (with_dummy_range (RecordField fields i)) in
List.iter (fun f ->
Options.debug_print_string (Printf.sprintf "Bitfields: Field %s has comments <%s>\n"
(print_field f)
(String.concat "\n" f.comments)))
fields;
let fields =
match fields with
| [{ v = AtomicField af ; range = range ; comments = comments }] ->
let af' = { af.v with field_dependence = false } in
let af' = { af with v = af' } in
[{ v = AtomicField af; range = range; comments = comments }]
| _ -> fields
in
decl_with_v d (Record names params where fields)
| _ -> d | false |
BitFields.fst | BitFields.group_bit_fields | val group_bit_fields (rewrite_composite_field: (field -> ML field)) (fields: list field)
: ML (list grouped_fields) | val group_bit_fields (rewrite_composite_field: (field -> ML field)) (fields: list field)
: ML (list grouped_fields) | let group_bit_fields (rewrite_composite_field: field -> ML field)
(fields: list field)
: ML (list grouped_fields)
= List.fold_right
(fun field out ->
match field.v with
| RecordField _ _
| SwitchCaseField _ _ ->
Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None ->
Inl field :: out
| Some (Inl _) ->
failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields)::tl ->
if index = bf.v.bitfield_identifier
then Inr(index, typ, af :: atomic_fields) :: tl //extend this bitfield group
else Inr(bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out //new bitfield group
)
fields
[] | {
"file_name": "src/3d/BitFields.fst",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 9,
"end_line": 62,
"start_col": 0,
"start_line": 34
} | (*
Copyright 2019 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module BitFields
open FStar.List.Tot
open FStar.Mul
open Ast
open FStar.All
module B = Binding
module H = Hashtable
(* This module implements a pass over the source AST
coalescing adjacent bit fields and replacing expressions on
bitfields using offsets into larger fgields
*)
let bitfield_group = int & typ & list atomic_field
let grouped_fields = either field bitfield_group | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Options.fsti.checked",
"Hashtable.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.All.fst.checked",
"Binding.fsti.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "BitFields.fst"
} | [
{
"abbrev": true,
"full_module": "Hashtable",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Binding",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "Ast",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"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 | rewrite_composite_field: (_: Ast.field -> FStar.All.ML Ast.field) -> fields: Prims.list Ast.field
-> FStar.All.ML (Prims.list BitFields.grouped_fields) | FStar.All.ML | [
"ml"
] | [] | [
"Ast.field",
"Prims.list",
"FStar.List.fold_right",
"Ast.with_meta_t",
"Ast.field'",
"Ast.either",
"FStar.Pervasives.Native.tuple3",
"Prims.int",
"Ast.typ",
"Ast.atomic_field'",
"Ast.__proj__Mkwith_meta_t__item__v",
"Ast.ident",
"Prims.Cons",
"Ast.Inl",
"FStar.Pervasives.Native.tuple2",
"Ast.expr",
"Ast.case",
"Ast.__proj__Mkatomic_field'__item__field_bitwidth",
"FStar.All.failwith",
"Ast.bitfield_attr",
"Prims.op_Equality",
"Ast.__proj__Mkbitfield_attr'__item__bitfield_identifier",
"Ast.bitfield_attr'",
"Ast.Inr",
"FStar.Pervasives.Native.Mktuple3",
"Prims.bool",
"Ast.__proj__Mkbitfield_attr'__item__bitfield_type",
"Prims.Nil",
"BitFields.grouped_fields"
] | [] | false | true | false | false | false | let group_bit_fields (rewrite_composite_field: (field -> ML field)) (fields: list field)
: ML (list grouped_fields) =
| List.fold_right (fun field out ->
match field.v with
| RecordField _ _ | SwitchCaseField _ _ -> Inl (rewrite_composite_field field) :: out
| AtomicField af ->
match af.v.field_bitwidth with
| None -> Inl field :: out
| Some (Inl _) -> failwith "Bit fields should have been elaborated already"
| Some (Inr bf) ->
match out with
| Inr (index, typ, atomic_fields) :: tl ->
if index = bf.v.bitfield_identifier
then Inr (index, typ, af :: atomic_fields) :: tl
else Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out
| _ -> Inr (bf.v.bitfield_identifier, bf.v.bitfield_type, [af]) :: out)
fields
[] | false |
CQueue.fst | CQueue.vbind0 | val vbind0 (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot vprop | val vbind0 (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot vprop | let vbind0
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
: Tot vprop
= a `vdep` vbind0_payload a t b `vrewrite` vbind0_rewrite a t b | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 63,
"end_line": 183,
"start_col": 0,
"start_line": 178
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (p:Type u#a) : Type0 = squash p
(* BEGIN library *)
let intro_vrewrite_no_norm (#opened:inames)
(v: vprop) (#t: Type) (f: (t_of v) -> GTot t)
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v))
=
intro_vrewrite v f
let elim_vrewrite_no_norm (#opened:inames)
(v: vprop)
(#t: Type)
(f: ((t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v))
=
elim_vrewrite v f
let vconst_sel
(#a: Type)
(x: a)
: Tot (selector a (hp_of emp))
= fun _ -> x
[@@ __steel_reduce__]
let vconst'
(#a: Type)
(x: a)
: GTot vprop'
= {
hp = hp_of emp;
t = a;
sel = vconst_sel x;
}
[@@ __steel_reduce__]
let vconst (#a: Type) (x: a) : Tot vprop = VUnit (vconst' x)
let intro_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
emp
(fun _ -> vconst x)
(fun _ -> True)
(fun _ _ h' -> h' (vconst x) == x)
=
change_slprop_rel
emp
(vconst x)
(fun _ y -> y == x)
(fun _ -> ())
let elim_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
(vconst x)
(fun _ -> emp)
(fun _ -> True)
(fun h _ _ -> h (vconst x) == x)
=
change_slprop_rel
(vconst x)
emp
(fun y _ -> y == x)
(fun _ -> ())
let vpure_sel'
(p: prop)
: Tot (selector' (squash p) (Steel.Memory.pure p))
= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
let vpure_sel
(p: prop)
: Tot (selector (squash p) (Steel.Memory.pure p))
= vpure_sel' p
[@@ __steel_reduce__]
let vpure'
(p: prop)
: GTot vprop'
= {
hp = Steel.Memory.pure p;
t = squash p;
sel = vpure_sel p;
}
[@@ __steel_reduce__]
let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
let intro_vpure
(#opened: _)
(p: prop)
: SteelGhost unit opened
emp
(fun _ -> vpure p)
(fun _ -> p)
(fun _ _ h' -> p)
=
change_slprop_rel
emp
(vpure p)
(fun _ _ -> p)
(fun m -> pure_interp p m)
let elim_vpure
(#opened: _)
(p: prop)
: SteelGhost unit opened
(vpure p)
(fun _ -> emp)
(fun _ -> True)
(fun _ _ _ -> p)
=
change_slprop_rel
(vpure p)
emp
(fun _ _ -> p)
(fun m -> pure_interp p m; reveal_emp (); intro_emp m)
val intro_vdep2 (#opened:inames)
(v: vprop)
(q: vprop)
(x: t_of v)
(p: (t_of v -> Tot vprop))
: SteelGhost unit opened
(v `star` q)
(fun _ -> vdep v p)
(requires (fun h ->
q == p x /\
x == h v
))
(ensures (fun h _ h' ->
let x2 = h' (vdep v p) in
q == p (h v) /\
dfst x2 == (h v) /\
dsnd x2 == (h q)
))
let intro_vdep2
v q x p
=
intro_vdep v q p
let vbind0_payload
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
(x: t_of a)
: Tot vprop
= vpure (t == t_of (b x)) `star` b x
let vbind0_rewrite
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
(x: normal (t_of (vdep a (vbind0_payload a t b))))
: Tot t
= snd (dsnd x) | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.fst"
} | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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.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 |
a: Steel.Effect.Common.vprop ->
t: Type0 ->
b: (_: Steel.Effect.Common.t_of a -> Steel.Effect.Common.vprop)
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.vrewrite",
"Steel.Effect.Common.vdep",
"CQueue.vbind0_payload",
"CQueue.vbind0_rewrite"
] | [] | false | false | false | false | false | let vbind0 (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot vprop =
| (a `vdep` (vbind0_payload a t b)) `vrewrite` (vbind0_rewrite a t b) | false |
CQueue.fst | CQueue.vbind_hp | val vbind_hp (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot (slprop u#1) | val vbind_hp (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot (slprop u#1) | let vbind_hp // necessary to hide the attribute on hp_of
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
: Tot (slprop u#1)
= hp_of (vbind0 a t b) | {
"file_name": "share/steel/examples/steel/CQueue.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 22,
"end_line": 190,
"start_col": 0,
"start_line": 185
} | module CQueue
open CQueue.LList
#set-options "--ide_id_info_off"
//Re-define squash, since this module explicitly
//replies on proving equalities of the form `t_of v == squash p`
//which are delicate in the presence of optimizations that
//unfold `Prims.squash (p /\ q)`to _:unit{p /\ q}
//See Issue #2496
let squash (p:Type u#a) : Type0 = squash p
(* BEGIN library *)
let intro_vrewrite_no_norm (#opened:inames)
(v: vprop) (#t: Type) (f: (t_of v) -> GTot t)
: SteelGhost unit opened v (fun _ -> vrewrite v f)
(fun _ -> True) (fun h _ h' -> h' (vrewrite v f) == f (h v))
=
intro_vrewrite v f
let elim_vrewrite_no_norm (#opened:inames)
(v: vprop)
(#t: Type)
(f: ((t_of v) -> GTot t))
: SteelGhost unit opened (vrewrite v f) (fun _ -> v)
(fun _ -> True)
(fun h _ h' -> h (vrewrite v f) == f (h' v))
=
elim_vrewrite v f
let vconst_sel
(#a: Type)
(x: a)
: Tot (selector a (hp_of emp))
= fun _ -> x
[@@ __steel_reduce__]
let vconst'
(#a: Type)
(x: a)
: GTot vprop'
= {
hp = hp_of emp;
t = a;
sel = vconst_sel x;
}
[@@ __steel_reduce__]
let vconst (#a: Type) (x: a) : Tot vprop = VUnit (vconst' x)
let intro_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
emp
(fun _ -> vconst x)
(fun _ -> True)
(fun _ _ h' -> h' (vconst x) == x)
=
change_slprop_rel
emp
(vconst x)
(fun _ y -> y == x)
(fun _ -> ())
let elim_vconst
(#opened: _)
(#a: Type)
(x: a)
: SteelGhost unit opened
(vconst x)
(fun _ -> emp)
(fun _ -> True)
(fun h _ _ -> h (vconst x) == x)
=
change_slprop_rel
(vconst x)
emp
(fun y _ -> y == x)
(fun _ -> ())
let vpure_sel'
(p: prop)
: Tot (selector' (squash p) (Steel.Memory.pure p))
= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
let vpure_sel
(p: prop)
: Tot (selector (squash p) (Steel.Memory.pure p))
= vpure_sel' p
[@@ __steel_reduce__]
let vpure'
(p: prop)
: GTot vprop'
= {
hp = Steel.Memory.pure p;
t = squash p;
sel = vpure_sel p;
}
[@@ __steel_reduce__]
let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
let intro_vpure
(#opened: _)
(p: prop)
: SteelGhost unit opened
emp
(fun _ -> vpure p)
(fun _ -> p)
(fun _ _ h' -> p)
=
change_slprop_rel
emp
(vpure p)
(fun _ _ -> p)
(fun m -> pure_interp p m)
let elim_vpure
(#opened: _)
(p: prop)
: SteelGhost unit opened
(vpure p)
(fun _ -> emp)
(fun _ -> True)
(fun _ _ _ -> p)
=
change_slprop_rel
(vpure p)
emp
(fun _ _ -> p)
(fun m -> pure_interp p m; reveal_emp (); intro_emp m)
val intro_vdep2 (#opened:inames)
(v: vprop)
(q: vprop)
(x: t_of v)
(p: (t_of v -> Tot vprop))
: SteelGhost unit opened
(v `star` q)
(fun _ -> vdep v p)
(requires (fun h ->
q == p x /\
x == h v
))
(ensures (fun h _ h' ->
let x2 = h' (vdep v p) in
q == p (h v) /\
dfst x2 == (h v) /\
dsnd x2 == (h q)
))
let intro_vdep2
v q x p
=
intro_vdep v q p
let vbind0_payload
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
(x: t_of a)
: Tot vprop
= vpure (t == t_of (b x)) `star` b x
let vbind0_rewrite
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
(x: normal (t_of (vdep a (vbind0_payload a t b))))
: Tot t
= snd (dsnd x)
[@@__steel_reduce__; __reduce__]
let vbind0
(a: vprop)
(t: Type0)
(b: (t_of a -> Tot vprop))
: Tot vprop
= a `vdep` vbind0_payload a t b `vrewrite` vbind0_rewrite a t b | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked",
"CQueue.LList.fsti.checked"
],
"interface_file": true,
"source_file": "CQueue.fst"
} | [
{
"abbrev": false,
"full_module": "CQueue.LList",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"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.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 |
a: Steel.Effect.Common.vprop ->
t: Type0 ->
b: (_: Steel.Effect.Common.t_of a -> Steel.Effect.Common.vprop)
-> Steel.Memory.slprop | Prims.Tot | [
"total"
] | [] | [
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Steel.Effect.Common.hp_of",
"CQueue.vbind0",
"Steel.Memory.slprop"
] | [] | false | false | false | false | false | let vbind_hp (a: vprop) (t: Type0) (b: (t_of a -> Tot vprop)) : Tot (slprop u#1) =
| hp_of (vbind0 a t b) | false |
Vale.X64.InsSha.fst | Vale.X64.InsSha.va_code_SHA256_msg1 | val va_code_SHA256_msg1 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | val va_code_SHA256_msg1 : dst:va_operand_xmm -> src:va_operand_xmm -> Tot va_code | let va_code_SHA256_msg1 dst src =
(mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src))) | {
"file_name": "obj/Vale.X64.InsSha.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 65,
"end_line": 57,
"start_col": 0,
"start_line": 56
} | module Vale.X64.InsSha
open Vale.Def.Types_s
open Vale.X64.Machine_s
open Vale.X64
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.InsLemmas
open Vale.X64.Taint_Semantics
open Vale.X64.Decls
open Vale.X64.CryptoInstructions_s
open Spec.Hash.Definitions
open Spec.SHA2
open Vale.X64.CPU_Features_s
module I = Vale.X64.Instructions_s
module S = Vale.X64.Machine_Semantics_s
module P = Vale.X64.Print_s
friend Vale.X64.Decls
#reset-options "--initial_fuel 4 --max_fuel 4 --max_ifuel 2 --z3rlimit 20"
//-- SHA256_rnds2
[@ "opaque_to_smt"]
let va_code_SHA256_rnds2 dst src =
(mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
[@ "opaque_to_smt"]
let va_codegen_success_SHA256_rnds2 dst src =
(va_ttrue ())
[@"opaque_to_smt"]
let va_lemma_SHA256_rnds2 va_b0 va_s0 dst src t block hash_orig =
va_reveal_opaque (`%va_code_SHA256_rnds2) (va_code_SHA256_rnds2 dst src);
let (va_old_s:va_state) = va_s0 in
va_ins_lemma (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src))) va_s0;
let (va_sM, va_fM) = va_eval_ins (mk_ins (make_instr (I.ins_SHA256_rnds2) (OReg dst) (OReg src)))
va_s0 in
lemma_sha256_rnds2 (va_eval_xmm va_old_s src) (va_eval_xmm va_old_s dst) (va_get_xmm 0 va_old_s)
t block hash_orig;
(va_sM, va_fM)
[@"opaque_to_smt"]
let va_wpProof_SHA256_rnds2 dst src t block hash_orig va_s0 va_k =
let (va_sM, va_f0) = va_lemma_SHA256_rnds2 (va_code_SHA256_rnds2 dst src) va_s0 dst src t block
hash_orig in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_ok va_sM (va_update_operand_xmm dst va_sM va_s0)));
va_lemma_norm_mods ([va_mod_xmm dst]) va_sM va_s0;
let va_g = () in
(va_sM, va_f0, va_g)
//--
//-- SHA256_msg1 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Taint_Semantics.fst.checked",
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.Decls.fst.checked",
"Vale.X64.CryptoInstructions_s.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Spec.SHA2.fsti.checked",
"Spec.Hash.Definitions.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Vale.X64.InsSha.fst"
} | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Vale.X64.Instructions_s",
"short_module": "I"
},
{
"abbrev": false,
"full_module": "Vale.X64.CryptoInstructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Taint_Semantics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Loops",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.UInt32",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.SHA.SHA_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Hash.Definitions",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.SHA2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.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": 4,
"initial_ifuel": 0,
"max_fuel": 4,
"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": 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 | dst: Vale.X64.Decls.va_operand_xmm -> src: Vale.X64.Decls.va_operand_xmm -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Decls.va_operand_xmm",
"Vale.X64.Taint_Semantics.mk_ins",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.opXmm",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_SHA256_msg1",
"Vale.X64.Machine_s.OReg",
"Vale.X64.Machine_s.quad32",
"Vale.X64.Machine_s.reg_xmm",
"Vale.X64.Decls.va_code"
] | [] | false | false | false | true | false | let va_code_SHA256_msg1 dst src =
| (mk_ins (make_instr (I.ins_SHA256_msg1) (OReg dst) (OReg src))) | false |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.