file_name stringlengths 5 52 | name stringlengths 4 95 | original_source_type stringlengths 0 23k | source_type stringlengths 9 23k | source_definition stringlengths 9 57.9k | source dict | source_range dict | file_context stringlengths 0 721k | dependencies dict | opens_and_abbrevs listlengths 2 94 | vconfig dict | interleaved bool 1
class | verbose_type stringlengths 1 7.42k | effect stringclasses 118
values | effect_flags listlengths 0 2 | mutual_with listlengths 0 11 | ideal_premises listlengths 0 236 | proof_features listlengths 0 1 | is_simple_lemma bool 2
classes | is_div bool 2
classes | is_proof bool 2
classes | is_simply_typed bool 2
classes | is_type bool 2
classes | partial_definition stringlengths 5 3.99k | completed_definiton stringlengths 1 1.63M | isa_cross_project_example bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_at_least | val i_at_least : n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | let i_at_least (#r:rid) (#a:Type) (#p:(seq a -> Type)) (n:nat) (x:a) (m:i_seq r a p) (h:mem) =
Seq.length (HS.sel h m) > n
/\ Seq.index (HS.sel h m) n == x | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 117,
"start_col": 0,
"start_line": 115
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p -> h: FStar.Monotonic.HyperStack.mem
-> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.grows_p",
"Prims.eq2",
"FStar.Seq.B... | [] | false | false | false | false | true | let i_at_least (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p) (h: mem) =
| Seq.length (HS.sel h m) > n /\ Seq.index (HS.sel h m) n == x | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.op_At | val op_At : s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | let op_At s1 s2 = Seq.append s1 s2 | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 42,
"end_line": 210,
"start_col": 8,
"start_line": 210
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s1: FStar.Seq.Base.seq _ -> s2: FStar.Seq.Base.seq _ -> FStar.Seq.Base.seq _ | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append"
] | [] | false | false | false | true | false | let ( @ ) s1 s2 =
| Seq.append s1 s2 | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_prefix | val map_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | let map_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(bs:seq b)
(h:mem) =
grows bs (map f (HS.sel h r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 269,
"start_col": 0,
"start_line": 264
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.map",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | false | false | false | true | let map_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
(h: mem)
=
| grows bs (map f (HS.sel h r)) | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.alloc_mref_seq | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | val alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) | let alloc_mref_seq (#a:Type) (r:rid) (init:seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures (fun h0 m h1 ->
HS.contains h1 m /\
HS.sel h1 m == init /\
HST.ralloc_post r init h0 m h1))
= ralloc r init | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 68,
"start_col": 0,
"start_line": 61
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Monotonic.Seq.rid -> init: FStar.Seq.Base.seq a
-> FStar.HyperStack.ST.ST
(FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mref",
"FStar.HyperStack.ST.m_rref",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.witnessed",
"FStar.HyperStack.ST.region_contains_pred",
"Prims.l_and",
"FSt... | [] | false | true | false | false | false | let alloc_mref_seq (#a: Type) (r: rid) (init: seq a)
: ST (m_rref r (seq a) grows)
(requires (fun _ -> HST.witnessed (region_contains_pred r)))
(ensures
(fun h0 m h1 -> HS.contains h1 m /\ HS.sel h1 m == init /\ HST.ralloc_post r init h0 m h1)) =
| ralloc r init | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_at_least_is_stable | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | val i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) | let i_at_least_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (n:nat) (x:a) (m:i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 121,
"start_col": 0,
"start_line": 119
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> x: a -> m: FStar.Monotonic.Seq.i_seq r a p
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t m (FStar.Monotonic.Seq.i_at_least n x m)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.i_seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
... | [] | true | false | true | false | false | let i_at_least_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (n: nat) (x: a) (m: i_seq r a p)
: Lemma (ensures stable_on_t m (i_at_least n x m)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_prefix | val collect_prefix : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | let collect_prefix (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(bs:seq b)
(h:mem) =
grows bs (collect f (HS.sel h r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 332,
"start_col": 0,
"start_line": 327
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b ->
h: FStar.Monotonic.HyperStack.mem
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.HyperStack.mem",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.HyperStack.sel"
] | [] | false | false | false | false | true | let collect_prefix
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
(h: mem)
=
| grows bs (collect f (HS.sel h r)) | false | |
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_mul_st | val bn_almost_mont_mul_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_almost_mont_mul_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> bM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM bM /\
eq_or_disjoin... | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 90,
"end_line": 52,
"start_col": 0,
"start_line": 40
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tac... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": true... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modif... | [] | false | false | false | false | true | let bn_almost_mont_mul_st (t: limb_t) (len: BN.meta_len t) =
| n: lbignum t len -> mu: limb t -> aM: lbignum t len -> bM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h ->
live h aM /\ live h bM /\ live h resM /\ live h n /\ disjoint resM n /\
eq_or_disjoint aM bM /\ eq_or_disjoint aM resM /\ eq_or_disjoint bM resM)
(en... | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_has_at_index | val collect_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | let collect_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b))
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length (collect f s)
/\ Seq.index (collect f s) n == v | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 353,
"start_col": 0,
"start_line": 347
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"FStar.Monotonic.Seq.collect",
"Prims.eq2",
"FStar.Seq.Base.ind... | [] | false | false | false | false | true | let collect_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
(h: mem)
=
| let s = HS.sel h r in
n < Seq.length (collect f s) /\ Seq.index (collect f s) n == v | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.int_at_most_is_stable | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | val int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) | let int_at_most_is_stable (#r:rid) (#a:Type) (#p:seq a -> Type) (is:i_seq r a p) (k:int)
: Lemma (ensures stable_on_t is (int_at_most k is))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 128,
"start_col": 0,
"start_line": 126
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | is: FStar.Monotonic.Seq.i_seq r a p -> k: Prims.int
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t is (FStar.Monotonic.Seq.int_at_most k is)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.i_seq",
"Prims.int",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.grows_p",
... | [] | true | false | true | false | false | let int_at_most_is_stable (#r: rid) (#a: Type) (#p: (seq a -> Type)) (is: i_seq r a p) (k: int)
: Lemma (ensures stable_on_t is (int_at_most k is)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_least_is_stable | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | val at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) | let at_least_is_stable (#a:Type) (#i:rid) (n:nat) (x:a) (r:m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 79,
"start_col": 0,
"start_line": 77
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
n: Prims.nat ->
x: a ->
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.at_least n x r)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_least",... | [] | true | false | true | false | false | let at_least_is_stable (#a: Type) (#i: rid) (n: nat) (x: a) (r: m_rref i (seq a) grows)
: Lemma (ensures stable_on_t r (at_least n x r)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_read | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | val i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) | let i_read (#a:Type) (#p:Seq.seq a -> Type) (#r:rid) (m:i_seq r a p)
: ST (s:seq a{p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0==h1 /\ x == i_sel h0 m))
= !m | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 6,
"end_line": 138,
"start_col": 0,
"start_line": 134
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | m: FStar.Monotonic.Seq.i_seq r a p -> FStar.HyperStack.ST.ST (s: FStar.Seq.Base.seq a {p s}) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.l_or",
"Prims.squash",
"FStar.Monotonic.Seq.i_sel"
] | [] | false | true | false | false | false | let i_read (#a: Type) (#p: (Seq.seq a -> Type)) (#r: rid) (m: i_seq r a p)
: ST (s: seq a {p s})
(requires (fun h -> True))
(ensures (fun h0 x h1 -> h0 == h1 /\ x == i_sel h0 m)) =
| !m | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.grows_p | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | val grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) | let grows_p (#a:Type) (p:seq a -> Type) :Preorder.preorder (s:seq a{p s}) =
fun s1 s2 -> grows s1 s2 | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 105,
"start_col": 0,
"start_line": 104
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | p: (_: FStar.Seq.Base.seq a -> Type) -> FStar.Preorder.preorder (s: FStar.Seq.Base.seq a {p s}) | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Preorder.preorder"
] | [] | false | false | false | false | false | let grows_p (#a: Type) (p: (seq a -> Type)) : Preorder.preorder (s: seq a {p s}) =
| fun s1 s2 -> grows s1 s2 | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.invariant | val invariant : s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | let invariant (s:seq nat) =
forall (i:nat) (j:nat). i < Seq.length s /\ j < Seq.length s /\ i<>j
==> Seq.index s i <> Seq.index s j | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 37,
"end_line": 167,
"start_col": 8,
"start_line": 165
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq Prims.nat -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_disEquality",
"FStar.Seq.Base.index",
"Prims.logical"
] | [] | false | false | false | true | true | let invariant (s: seq nat) =
| forall (i: nat) (j: nat).
i < Seq.length s /\ j < Seq.length s /\ i <> j ==> Seq.index s i <> Seq.index s j | false | |
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_reduction_st | val bn_almost_mont_reduction_st : t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | let bn_almost_mont_reduction_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack unit
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)... | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 79,
"end_line": 32,
"start_col": 0,
"start_line": 22
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tac... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": fals... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
t: Hacl.Bignum.Definitions.limb_t ->
len:
Lib.IntTypes.size_t
{ 0 < Lib.IntTypes.v len /\
Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t }
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Defi... | [] | false | false | false | false | true | let bn_almost_mont_reduction_st (t: limb_t) (len: size_t{0 < v len /\ v len + v len <= max_size_t}) =
| n: lbignum t len -> mu: limb t -> c: lbignum t (len +! len) -> res: lbignum t len
-> Stack unit
(requires
fun h ->
live h n /\ live h c /\ live h res /\ disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures
fun h0 _ h1 ->
modifies (loc res |+| loc c) h0 h1 /\
... | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.write_at_end | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.s... | val write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.s... | let write_at_end (#a:Type) (#i:rid) (r:m_rref i (seq a) grows) (x:a)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
contains h1 r
/\ modifies_one i h0 h1
/\ modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1
/\ HS.sel h1 r == Seq.snoc (HS.sel h0 r) x
... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 98,
"start_col": 0,
"start_line": 82
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows -> x: a
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.at_least_is_stable",
"FStar.HyperStack.ST.op_Colon_... | [] | false | true | false | false | false | let write_at_end (#a: Type) (#i: rid) (r: m_rref i (seq a) grows) (x: a)
: ST unit
(requires (fun h -> True))
(ensures
(fun h0 _ h1 ->
contains h1 r /\ modifies_one i h0 h1 /\
modifies_ref i (Set.singleton (HS.as_addr r)) h0 h1 /\
HS.sel h1 r == Seq.snoc (HS.s... | recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
at_least_is_stable n x r;
Seq.contains_snoc s0 x;
mr_witness r (at_least n x r) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.test0 | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | val test0: r:rid -> a:m_rref r (seq nat) grows -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (HS.sel h a)))
(ensures (fun h0 result h1 -> True)) | let test0 r a k =
let h0 = HST.get() in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k) in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 57,
"end_line": 178,
"start_col": 0,
"start_line": 172
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Monotonic.Seq.rid ->
a: FStar.HyperStack.ST.m_rref r (FStar.Seq.Base.seq Prims.nat) FStar.Monotonic.Seq.grows ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"Prims.nat",
"FStar.Monotonic.Seq.grows",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"FStar.Seq.Properties.contains_intro"... | [] | false | true | false | false | false | let test0 r a k =
| let h0 = HST.get () in
let _ =
let s = HS.sel h0 a in
at_least_is_stable k (Seq.index (HS.sel h0 a) k) a;
Seq.contains_intro s k (Seq.index s k)
in
mr_witness a (at_least k (Seq.index (HS.sel h0 a) k) a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.itest | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | val itest: r:rid -> a:i_seq r nat invariant -> k:nat -> ST unit
(requires (fun h -> k < Seq.length (i_sel h a)))
(ensures (fun h0 result h1 -> True)) | let itest r a k =
let h0 = HST.get() in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 58,
"end_line": 186,
"start_col": 0,
"start_line": 183
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.Monotonic.Seq.rid ->
a: FStar.Monotonic.Seq.i_seq r Prims.nat FStar.Monotonic.Seq.invariant ->
k: Prims.nat
-> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"Prims.nat",
"FStar.Monotonic.Seq.invariant",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.i_sel",
"Prims.unit",
"FSt... | [] | false | true | false | false | false | let itest r a k =
| let h0 = HST.get () in
i_at_least_is_stable k (Seq.index (i_sel h0 a) k) a;
mr_witness a (i_at_least k (Seq.index (i_sel h0 a) k) a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | val map: ('a -> Tot 'b) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | let rec map f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 39,
"end_line": 202,
"start_col": 0,
"start_line": 199
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | false | true | false | let rec map f s =
| if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.snoc (map f prefix) (f last) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.i_write_at_end | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1... | val i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1... | let i_write_at_end (#a:Type) (#p:seq a -> Type) (#rgn:rid) (r:i_seq rgn a p) (x:a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures (fun h0 _ h1 ->
i_contains r h1
/\ modifies_one rgn h0 h1
/\ modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1
/... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 160,
"start_col": 0,
"start_line": 144
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: FStar.Monotonic.Seq.i_seq rgn a p -> x: a -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.i_seq",
"FStar.HyperStack.ST.mr_witness",
"FStar.Monotonic.Seq.grows_p",
"FStar.Monotonic.Seq.i_at_least",
"Prims.unit",
"FStar.Seq.Properties.contains_snoc",
"FStar.Monotonic.Seq.i_at_least_is_stable",
"FStar.HyperStack.ST.op_C... | [] | false | true | false | false | false | let i_write_at_end (#a: Type) (#p: (seq a -> Type)) (#rgn: rid) (r: i_seq rgn a p) (x: a)
: ST unit
(requires (fun h -> p (Seq.snoc (i_sel h r) x)))
(ensures
(fun h0 _ h1 ->
i_contains r h1 /\ modifies_one rgn h0 h1 /\
modifies_ref rgn (Set.singleton (HS.as_addr r)) h0 h1... | recall r;
let s0 = !r in
let n = Seq.length s0 in
r := Seq.snoc s0 x;
i_at_least_is_stable n x r;
contains_snoc s0 x;
mr_witness r (i_at_least n x r) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_most_log_len | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | val at_most_log_len: #l: rid -> #a: Type -> x: nat -> log: log_t l a -> mem -> GTot Type0 | let at_most_log_len (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: mem -> GTot Type0
= fun h -> x <= Seq.length (HS.sel h log) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 372,
"start_col": 0,
"start_line": 370
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a -> _: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Type0 | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.HyperStack.mem",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Monotonic.HyperStack.sel",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows"
] | [] | false | false | false | false | true | let at_most_log_len (#l: rid) (#a: Type) (x: nat) (log: log_t l a) : mem -> GTot Type0 =
| fun h -> x <= Seq.length (HS.sel h log) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.increases | val increases : x: Prims.int -> y: Prims.int -> Prims.logical | let increases (x:int) (y:int) = b2t (x <= y) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 368,
"start_col": 0,
"start_line": 368
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.int -> y: Prims.int -> Prims.logical | Prims.Tot | [
"total"
] | [] | [
"Prims.int",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.logical"
] | [] | false | false | false | true | true | let increases (x y: int) =
| b2t (x <= y) | false | |
Hacl.Impl.Ed25519.Sign.fst | Hacl.Impl.Ed25519.Sign.sign_compute_s | val sign_compute_s (r hs:lbuffer uint64 5ul) (a s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h r /\ live h hs /\ live h a /\ live h s /\
disjoint s r /\ disjoint s hs /\ disjoint s a /\
F56.scalar_inv_full_t h r /\ F56.scalar_inv_full_t h hs)
(ensures fun h0 _ h1 -> modifies (loc s) h0 h1... | val sign_compute_s (r hs:lbuffer uint64 5ul) (a s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h r /\ live h hs /\ live h a /\ live h s /\
disjoint s r /\ disjoint s hs /\ disjoint s a /\
F56.scalar_inv_full_t h r /\ F56.scalar_inv_full_t h hs)
(ensures fun h0 _ h1 -> modifies (loc s) h0 h1... | let sign_compute_s r hs a s =
push_frame ();
let aq = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes aq a;
Hacl.Impl.BignumQ.Mul.mul_modq aq hs aq;
Hacl.Impl.BignumQ.Mul.add_modq aq r aq;
assert_norm (0x100000000000000 == pow2 56);
Hacl.Impl.Store56.store_56 s aq;
pop_frame () | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 53,
"start_col": 0,
"start_line": 45
} | module Hacl.Impl.Ed25519.Sign
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.Big... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.Store56.fst.checked"... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: Lib.Buffer.lbuffer Lib.IntTypes.uint64 5ul ->
hs: Lib.Buffer.lbuffer Lib.IntTypes.uint64 5ul ->
a: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint64",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.uint8",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Store56.store_56",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.pow2",
"Hacl.Impl.BignumQ.Mul.add_modq",
"Hacl.Impl.Big... | [] | false | true | false | false | false | let sign_compute_s r hs a s =
| push_frame ();
let aq = create 5ul (u64 0) in
Hacl.Impl.Load56.load_32_bytes aq a;
Hacl.Impl.BignumQ.Mul.mul_modq aq hs aq;
Hacl.Impl.BignumQ.Mul.add_modq aq r aq;
assert_norm (0x100000000000000 == pow2 56);
Hacl.Impl.Store56.store_56 s aq;
pop_frame () | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_length | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | val map_length: f:('a -> Tot 'b) -> s1:seq 'a -> Lemma
(requires True)
(ensures (Seq.length s1 = Seq.length (map f s1)))
(decreases (length s1))
[SMTPat (Seq.length (map f s1))] | let rec map_length f s1 =
if Seq.length s1 = 0 then ()
else let prefix, last = un_snoc s1 in
map_length f prefix | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 242,
"start_col": 0,
"start_line": 239
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.length s1 = FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))
(decreases FStar.Seq.Base.length s1)
[SMTPat (FStar.Seq.Base.length (FStar.Monotonic.Seq.map f s1))] | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Monotonic.Seq.map_length",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | true | false | false | let rec map_length f s1 =
| if Seq.length s1 = 0
then ()
else
let prefix, last = un_snoc s1 in
map_length f prefix | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_append | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | val map_append: f:('a -> Tot 'b) -> s1:seq 'a -> s2:seq 'a -> Lemma
(requires True)
(ensures (map f (s1@s2) == (map f s1 @ map f s2)))
(decreases (Seq.length s2)) | let rec map_append f s_1 s_2 =
if Seq.length s_2 = 0
then (cut (Seq.equal (s_1@s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else (let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1@s_2) (S... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 230,
"start_col": 0,
"start_line": 217
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (s1 @ s2) ==
FStar.Monotonic.Seq.map f s1 @ FStar.Monotonic.Seq.map f s2)
(decreases FStar.Seq.Base.length s2) | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.cut",
"FStar.Seq.Base.equal",
"FStar.Monotonic.Seq.op_At",
"FStar.Monotonic.Seq.map",
"Prims.unit",
"Prims.bool",
"FStar.Monotonic.Seq.map_snoc",
"FStar.Seq.Properties.snoc",
"FStar.Monotonic.Seq.map_appe... | [
"recursion"
] | false | false | true | false | false | let rec map_append f s_1 s_2 =
| if Seq.length s_2 = 0
then
(cut (Seq.equal (s_1 @ s_2) s_1);
cut (Seq.equal (map f s_1 @ map f s_2) (map f s_1)))
else
(let prefix_2, last = un_snoc s_2 in
let m_s_1 = map f s_1 in
let m_p_2 = map f prefix_2 in
let flast = f last in
cut (Seq.equal (s_1 @ s_2) (Seq.snoc (s_1 @ prefix_2) last));
... | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.un_snoc | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | val un_snoc: #a: Type -> s:seq a {Seq.length s > 0} -> Tot(seq a * a) | let un_snoc #a s =
let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 195,
"start_col": 0,
"start_line": 193
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | s: FStar.Seq.Base.seq a {FStar.Seq.Base.length s > 0} -> FStar.Seq.Base.seq a * a | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.b2t",
"Prims.op_GreaterThan",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.index",
"Prims.int",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2"
] | [] | false | false | false | false | false | let un_snoc #a s =
| let last = Seq.length s - 1 in
Seq.slice s 0 last, Seq.index s last | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_has_at_index | val map_has_at_index : r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | let map_has_at_index (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b)
(n:nat) (v:b) (h:mem) =
let s = HS.sel h r in
n < Seq.length s
/\ Seq.index (map f s) n == v | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 31,
"end_line": 283,
"start_col": 0,
"start_line": 277
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.GTot Prims.logical | Prims.GTot | [
"sometrivial"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Monotonic.Seq.map",... | [] | false | false | false | false | true | let map_has_at_index
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
(h: mem)
=
| let s = HS.sel h r in
n < Seq.length s /\ Seq.index (map f s) n == v | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_grows | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | val map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) | let map_grows (#a:Type) (#b:Type) (f:a -> Tot b)
(s1:seq a) (s3:seq a)
: Lemma (grows s1 s3
==> grows (map f s1) (map f s3))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 262,
"start_col": 0,
"start_line": 257
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: a -> b) -> s1: FStar.Seq.Base.seq a -> s3: FStar.Seq.Base.seq a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s3 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.map f s1) (FStar.Monotonic.Seq.map f s3)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"FStar.Monotonic.Seq.map",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let map_grows (#a #b: Type) (f: (a -> Tot b)) (s1 s3: seq a)
: Lemma (grows s1 s3 ==> grows (map f s1) (map f s3)) =
| reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | false |
Hacl.Impl.Ed25519.Sign.fst | Hacl.Impl.Ed25519.Sign.point_mul_g_compress | val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s))) | val point_mul_g_compress (out s:lbuffer uint8 32ul) : Stack unit
(requires fun h ->
live h out /\ live h s /\ disjoint s out)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
as_seq h1 out == Spec.Ed25519.point_compress (Spec.Ed25519.point_mul_g (as_seq h0 s))) | let point_mul_g_compress out s =
push_frame ();
let tmp = create 20ul (u64 0) in
Hacl.Impl.Ed25519.Ladder.point_mul_g tmp s;
Hacl.Impl.Ed25519.PointCompress.point_compress out tmp;
pop_frame () | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Sign.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 32,
"start_col": 0,
"start_line": 27
} | module Hacl.Impl.Ed25519.Sign
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
module F51 = Hacl.Impl.Ed25519.Field51
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.Big... | {
"checked_file": "/",
"dependencies": [
"Spec.Ed25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.Store56.fst.checked"... | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Ed25519.Field51",
"short_module": "F51"
},
{
"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | out: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> s: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Hacl.Impl.Ed25519.PointCompress.point_compress",
"Hacl.Impl.Ed25519.Ladder.point_mul_g",
"Lib.Buffer.lbuffer_t",
"Lib.Buffer.MUT",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"... | [] | false | true | false | false | false | let point_mul_g_compress out s =
| push_frame ();
let tmp = create 20ul (u64 0) in
Hacl.Impl.Ed25519.Ladder.point_mul_g tmp s;
Hacl.Impl.Ed25519.PointCompress.point_compress out tmp;
pop_frame () | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_prefix_stable | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | val collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) | let collect_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot (seq b)) (bs:seq b)
: Lemma (stable_on_t r (collect_prefix r f bs))
= let aux : h0:mem -> h1:mem -> Lemma
(collect_prefix r f bs h0
/\ grows (HS.sel h0 r) (HS.sel h1 r)
==> collect_prefix r f bs h1) =
... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 22,
"end_line": 345,
"start_col": 0,
"start_line": 334
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_prefix r f bs)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Classical.forall_intro_2",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_imp",
"Prims.l_and",
"FStar.Monotonic.Seq.collect_prefix",
"FStar.Monotonic.HyperStack.sel",
"Prims.unit",
"P... | [] | false | false | true | false | false | let collect_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(bs: seq b)
: Lemma (stable_on_t r (collect_prefix r f bs)) =
| let aux: h0: mem -> h1: mem
-> Lemma
(collect_prefix r f bs h0 /\ grows (HS.sel h0 r) (HS.sel h1 r) ==> collect_prefix r f bs h1) =
fun h0 h1 ->
let s1 = HS.sel h0 r in
let s3 = HS.sel h1 r in
collect_grows f s1 s3
in
forall_intro_2 aux | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_index | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | val map_index: f:('a -> Tot 'b) -> s:seq 'a -> i:nat{i<Seq.length s} -> Lemma
(requires True)
(ensures (Seq.index (map f s) i == f (Seq.index s i)))
(decreases (Seq.length s))
[SMTPat (Seq.index (map f s) i)] | let rec map_index f s i =
if i = Seq.length s - 1
then ()
else let prefix, last = un_snoc s in
map_index f prefix i | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 27,
"end_line": 253,
"start_col": 0,
"start_line": 249
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> i: Prims.nat{i < FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures FStar.Seq.Base.index (FStar.Monotonic.Seq.map f s) i == f (FStar.Seq.Base.index s i))
(decreases FStar.Seq.Base.length s)
[SMTPat (FStar.Seq.Base.index (FStar.Monotonic.Seq.ma... | FStar.Pervasives.Lemma | [
"lemma",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Prims.bool",
"FStar.Monotonic.Seq.map_index",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | true | false | false | let rec map_index f s i =
| if i = Seq.length s - 1
then ()
else
let prefix, last = un_snoc s in
map_index f prefix i | false |
Hacl.Bignum.AlmostMontgomery.fsti | Hacl.Bignum.AlmostMontgomery.bn_almost_mont_sqr_st | val bn_almost_mont_sqr_st : t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | let bn_almost_mont_sqr_st (t:limb_t) (len:BN.meta_len t) =
n:lbignum t len
-> mu:limb t
-> aM:lbignum t len
-> resM:lbignum t len ->
Stack unit
(requires fun h ->
live h aM /\ live h resM /\ live h n /\
disjoint resM n /\ eq_or_disjoint aM resM)
(ensures fun h0 _ h1 -> modifies (loc resM) h0 h1... | {
"file_name": "code/bignum/Hacl.Bignum.AlmostMontgomery.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 75,
"end_line": 74,
"start_col": 0,
"start_line": 64
} | module Hacl.Bignum.AlmostMontgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
module S = Hacl.Spec.Bignum.AlmostMontgomery
module BN = Hacl.Bignum
module BM = Hacl.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.AlmostMontgomery.fsti.checked",
"Hacl.Bignum.Montgomery.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.Tac... | [
{
"abbrev": true,
"full_module": "Hacl.Bignum.Montgomery",
"short_module": "BM"
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.AlmostMontgomery",
"short_module": "S"
},
{
"abbrev": true... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | t: Hacl.Bignum.Definitions.limb_t -> len: Hacl.Bignum.meta_len t -> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.meta_len",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.modif... | [] | false | false | false | false | true | let bn_almost_mont_sqr_st (t: limb_t) (len: BN.meta_len t) =
| n: lbignum t len -> mu: limb t -> aM: lbignum t len -> resM: lbignum t len
-> Stack unit
(requires
fun h -> live h aM /\ live h resM /\ live h n /\ disjoint resM n /\ eq_or_disjoint aM resM)
(ensures
fun h0 _ h1 ->
modifies (loc resM) h0 h1 /\
as_seq h1 resM == S.bn_alm... | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | val collect: ('a -> Tot (seq 'b)) -> s:seq 'a -> Tot (seq 'b)
(decreases (Seq.length s)) | let rec collect f s =
if Seq.length s = 0 then Seq.empty
else let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 45,
"end_line": 302,
"start_col": 0,
"start_line": 299
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> Prims.Tot (FStar.Seq.Base.seq 'b) | Prims.Tot | [
"total",
""
] | [] | [
"FStar.Seq.Base.seq",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Monotonic.Seq.collect",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc"
] | [
"recursion"
] | false | false | false | true | false | let rec collect f s =
| if Seq.length s = 0
then Seq.empty
else
let prefix, last = un_snoc s in
Seq.append (collect f prefix) (f last) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_has_at_index_stable | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | val map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) | let map_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot b) (n:nat) (v:b)
: Lemma (stable_on_t r (map_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 289,
"start_col": 0,
"start_line": 285
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_has_at_index r f n v)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_has_at... | [] | true | false | true | false | false | let map_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(n: nat)
(v: b)
: Lemma (stable_on_t r (map_has_at_index r f n v)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_grows | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | val collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) | let collect_grows (f:'a -> Tot (seq 'b))
(s1:seq 'a) (s2:seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2))
= reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f:'a -> Tot (seq 'b)) (s1:seq 'a) (s2:seq 'a)
:Lemma (requires (grow... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 118,
"end_line": 325,
"start_col": 0,
"start_line": 312
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s1: FStar.Seq.Base.seq 'a -> s2: FStar.Seq.Base.seq 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.grows s1 s2 ==>
FStar.Monotonic.Seq.grows (FStar.Monotonic.Seq.collect f s1)
(FStar.Monotonic.Seq.collect f s2)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"FStar.Classical.arrow_to_impl",
"FStar.Monotonic.Seq.grows",
"FStar.Monotonic.Seq.collect",
"Prims.squash",
"Prims.unit",
"FStar.Seq.Base.length",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_Equality",
"Prims.nat",
"Prims._assert",
"FStar.Seq.Base.equal",
"Pri... | [] | false | false | true | false | false | let collect_grows (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (grows s1 s2 ==> grows (collect f s1) (collect f s2)) =
| reveal_opaque (`%grows) (grows #'a);
reveal_opaque (`%grows) (grows #'b);
let rec collect_grows_aux (f: ('a -> Tot (seq 'b))) (s1 s2: seq 'a)
: Lemma (requires (grows s1 s2))
(ensures (grows (collect f s1) (collect f s2)))
(decreases (Seq.length s2)) =
if length s1 = length s2
then assert (Seq.equal... | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_snoc | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | val map_snoc: f:('a -> Tot 'b) -> s:seq 'a -> a:'a -> Lemma
(map f (Seq.snoc s a) == Seq.snoc (map f s) (f a)) | let map_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 208,
"start_col": 0,
"start_line": 206
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.map f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Properties.snoc (FStar.Monotonic.Seq.map f s) (f a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | false | false | true | false | false | let map_snoc f s a =
| let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.map_prefix_stable | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | val map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) | let map_prefix_stable (#a:Type) (#b:Type) (#i:rid) (r:m_rref i (seq a) grows) (f:a -> Tot b) (bs:seq b)
:Lemma (stable_on_t r (map_prefix r f bs))
= reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 275,
"start_col": 0,
"start_line": 272
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> b) ->
bs: FStar.Seq.Base.seq b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.map_prefix r f bs)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.map_prefix",
"Prims.Nil... | [] | true | false | true | false | false | let map_prefix_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot b))
(bs: seq b)
: Lemma (stable_on_t r (map_prefix r f bs)) =
| reveal_opaque (`%grows) (grows #a);
reveal_opaque (`%grows) (grows #b) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_snoc | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | val collect_snoc: f:('a -> Tot (seq 'b)) -> s:seq 'a -> a:'a -> Lemma
(collect f (Seq.snoc s a) == Seq.append (collect f s) (f a)) | let collect_snoc f s a =
let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 26,
"end_line": 308,
"start_col": 0,
"start_line": 306
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | f: (_: 'a -> FStar.Seq.Base.seq 'b) -> s: FStar.Seq.Base.seq 'a -> a: 'a
-> FStar.Pervasives.Lemma
(ensures
FStar.Monotonic.Seq.collect f (FStar.Seq.Properties.snoc s a) ==
FStar.Seq.Base.append (FStar.Monotonic.Seq.collect f s) (f a)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Prims.cut",
"FStar.Seq.Base.equal",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"FStar.Monotonic.Seq.un_snoc",
"FStar.Seq.Properties.snoc"
] | [] | false | false | true | false | false | let collect_snoc f s a =
| let prefix, last = un_snoc (Seq.snoc s a) in
cut (Seq.equal prefix s) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.collect_has_at_index_stable | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | val collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) | let collect_has_at_index_stable (#a:Type) (#b:Type) (#i:rid)
(r:m_rref i (seq a) grows)
(f:a -> Tot (seq b)) (n:nat) (v:b)
: Lemma (stable_on_t r (collect_has_at_index r f n v))
= reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 46,
"end_line": 360,
"start_col": 0,
"start_line": 355
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
r: FStar.HyperStack.ST.m_rref i (FStar.Seq.Base.seq a) FStar.Monotonic.Seq.grows ->
f: (_: a -> FStar.Seq.Base.seq b) ->
n: Prims.nat ->
v: b
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t r (FStar.Monotonic.Seq.collect_has_at_index r f n v)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.HyperStack.ST.m_rref",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.nat",
"FStar.Classical.forall_intro_2",
"Prims.l_imp",
"FStar.Monotonic.Seq.collect",
"FStar.Monotonic.Seq.collect_grows",
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.P... | [] | false | false | true | false | false | let collect_has_at_index_stable
(#a #b: Type)
(#i: rid)
(r: m_rref i (seq a) grows)
(f: (a -> Tot (seq b)))
(n: nat)
(v: b)
: Lemma (stable_on_t r (collect_has_at_index r f n v)) =
| reveal_opaque (`%grows) (grows #b);
Classical.forall_intro_2 (collect_grows f) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.at_most_log_len_stable | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | val at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) | let at_most_log_len_stable (#l:rid) (#a:Type) (x:nat) (log:log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log))
= reveal_opaque (`%grows) (grows #a) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 38,
"end_line": 386,
"start_col": 0,
"start_line": 384
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.Pervasives.Lemma
(ensures FStar.HyperStack.ST.stable_on_t log (FStar.Monotonic.Seq.at_most_log_len x log)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Pervasives.reveal_opaque",
"FStar.Preorder.preorder",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"FStar.HyperStack.ST.stable_on_t",
"FStar.Monotonic.Seq.at_most_log... | [] | true | false | true | false | false | let at_most_log_len_stable (#l: rid) (#a: Type) (x: nat) (log: log_t l a)
: Lemma (stable_on_t log (at_most_log_len x log)) =
| reveal_opaque (`%grows) (grows #a) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.testify_seqn | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | val testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) | let testify_seqn (#a:Type0) (#i:rid) (#l:rid) (#log:log_t l a) (#max:nat) (ctr:seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 ->
h0==h1 /\
at_most_log_len (HS.sel h1 ctr) log h1))
= let n = !ctr in
testify (at_most_log_len n log) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 35,
"end_line": 431,
"start_col": 0,
"start_line": 424
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | ctr: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"Prims.nat",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.testify",
"FStar.Monotonic.Seq.at_most_log_len",
"Prims.unit",
"FStar.Monotonic.Seq.seqn_val",
"FStar.HyperStack.ST.op_Bang",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.Hy... | [] | false | true | false | false | false | let testify_seqn (#a: Type0) (#i #l: rid) (#log: log_t l a) (#max: nat) (ctr: seqn i log max)
: ST unit
(requires (fun h -> True))
(ensures (fun h0 _ h1 -> h0 == h1 /\ at_most_log_len (HS.sel h1 ctr) log h1)) =
| let n = !ctr in
testify (at_most_log_len n log) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.test | val test : i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | let test (i:rid) (l:rid) (a:Type0) (log:log_t l a) //(p:(nat -> Type))
(r:seqn i log 8) (h:mem)
= assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 82,
"end_line": 435,
"start_col": 8,
"start_line": 433
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
i: FStar.Monotonic.Seq.rid ->
l: FStar.Monotonic.Seq.rid ->
a: Type0 ->
log: FStar.Monotonic.Seq.log_t l a ->
r: FStar.Monotonic.Seq.seqn i log 8 ->
h: FStar.Monotonic.HyperStack.mem
-> Prims.unit | Prims.Tot | [
"total"
] | [] | [
"FStar.Monotonic.Seq.rid",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.Monotonic.HyperStack.mem",
"Prims._assert",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.HyperStack.sel",
"FStar.Monotonic.Seq.increases",
"FStar.Monotonic.Heap.sel",
... | [] | false | false | false | false | false | let test (i l: rid) (a: Type0) (log: log_t l a) (r: seqn i log 8) (h: mem) =
| assert (HS.sel h r = Heap.sel (FStar.Map.sel (HS.get_hmap h) i) (HS.as_ref r)) | false | |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.increment_seqn | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
... | val increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
... | let increment_seqn (#a:Type) (#l:rid) (#max:nat)
(#i:rid) (#log:log_t l a) ($c:seqn i log max)
: ST unit
(requires (fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\
n + 1 <= max))
(ensures (fun h0 _ h1 ->
modifies_one i h0 h1 /\
modifies_ref i... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 10,
"end_line": 422,
"start_col": 0,
"start_line": 406
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | $c: FStar.Monotonic.Seq.seqn i log max -> FStar.HyperStack.ST.ST Prims.unit | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.Monotonic.Seq.seqn",
"FStar.HyperStack.ST.op_Colon_Equals",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grow... | [] | false | true | false | false | false | let increment_seqn (#a: Type) (#l: rid) (#max: nat) (#i: rid) (#log: log_t l a) ($c: seqn i log max)
: ST unit
(requires
(fun h ->
let log = HS.sel h log in
let n = HS.sel h c in
n < Seq.length log /\ n + 1 <= max))
(ensures
(fun h0 _ h1 ->
... | reveal_opaque (`%grows) (grows #a);
recall c;
recall log;
let n = !c + 1 in
mr_witness log (at_most_log_len n log);
c := n | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_bytes | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | val crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} | let crypto_bytes :r:size_t{v r == FP.crypto_bytes FP.Frodo64} =
crypto_bytes FP.Frodo64 | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 25,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ] | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_bytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64"
] | [] | false | false | false | false | false | let crypto_bytes:r: size_t{v r == FP.crypto_bytes FP.Frodo64} =
| crypto_bytes FP.Frodo64 | false |
Steel.HigherReference.fsti | Steel.HigherReference.ghost_pts_to | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | val ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop | let ghost_pts_to (#a:_) (r:ghost_ref a) (p:perm) (x:a) : vprop =
to_vprop (ghost_pts_to_sl r p x) | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 34,
"end_line": 212,
"start_col": 7,
"start_line": 211
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false... | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Steel.HigherReference.ghost_ref a -> p: Steel.FractionalPermission.perm -> x: a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.HigherReference.ghost_ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.ghost_pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | true | false | let ghost_pts_to (#a: _) (r: ghost_ref a) (p: perm) (x: a) : vprop =
| to_vprop (ghost_pts_to_sl r p x) | false |
Steel.HigherReference.fsti | Steel.HigherReference.pts_to | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | val pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop | let pts_to (#a:Type u#1) (r:ref a) (p:perm) (v:a) : vprop =
to_vprop (pts_to_sl r p v) | {
"file_name": "lib/steel/Steel.HigherReference.fsti",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 28,
"end_line": 49,
"start_col": 7,
"start_line": 48
} | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.Memory.fsti.checked",
"Steel.FractionalPermission.fst.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false... | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: a
-> Steel.Effect.Common.vprop | Prims.Tot | [
"total"
] | [] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.to_vprop",
"Steel.HigherReference.pts_to_sl",
"Steel.Effect.Common.vprop"
] | [] | false | false | false | true | false | let pts_to (#a: Type u#1) (r: ref a) (p: perm) (v: a) : vprop =
| to_vprop (pts_to_sl r p v) | false |
FStar.Monotonic.Seq.fst | FStar.Monotonic.Seq.new_seqn | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies... | val new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies... | let new_seqn (#a:Type) (#l:rid) (#max:nat)
(i:rid) (init:nat) (log:log_t l a)
: ST (seqn i log max)
(requires (fun h ->
HST.witnessed (region_contains_pred i) /\
init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures (fun h0 c h1 -> //17-01-05 unify with ralloc_post?
... | {
"file_name": "ulib/FStar.Monotonic.Seq.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 17,
"end_line": 404,
"start_col": 0,
"start_line": 388
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Set.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Preorder.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Monotonic.Heap.fsti.checked",
"FStar.Map.fsti.checked",
"F... | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": true,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 1,
"initial_ifuel": 1,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | i: FStar.Monotonic.Seq.rid -> init: Prims.nat -> log: FStar.Monotonic.Seq.log_t l a
-> FStar.HyperStack.ST.ST (FStar.Monotonic.Seq.seqn i log max) | FStar.HyperStack.ST.ST | [] | [] | [
"FStar.Monotonic.Seq.rid",
"Prims.nat",
"FStar.Monotonic.Seq.log_t",
"FStar.HyperStack.ST.ralloc",
"FStar.Monotonic.Seq.seqn_val",
"FStar.Monotonic.Seq.increases",
"FStar.HyperStack.ST.mref",
"Prims.unit",
"FStar.HyperStack.ST.mr_witness",
"FStar.Seq.Base.seq",
"FStar.Monotonic.Seq.grows",
"FS... | [] | false | true | false | false | false | let new_seqn (#a: Type) (#l: rid) (#max: nat) (i: rid) (init: nat) (log: log_t l a)
: ST (seqn i log max)
(requires
(fun h ->
HST.witnessed (region_contains_pred i) /\ init <= max /\
init <= Seq.length (HS.sel h log)))
(ensures
(fun h0 c h1 ->
modifies... | reveal_opaque (`%grows) (grows #a);
recall log;
recall_region i;
mr_witness log (at_most_log_len init log);
ralloc i init | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_keypair | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_keypair: crypto_kem_keypair_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_keypair pk sk =
crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 37,
"start_col": 0,
"start_line": 36
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Frodo.KEM.crypto_kem_keypair_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_keypair",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_keypair pk sk =
| crypto_kem_keypair FP.Frodo64 FP.SHAKE128 pk sk | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_publickeybytes | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | val crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} | let crypto_publickeybytes :r:size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
normalize_term (crypto_publickeybytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_publickeybytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTyp... | [] | false | false | false | false | false | let crypto_publickeybytes:r: size_t{v r == FP.crypto_publickeybytes FP.Frodo64} =
| normalize_term (crypto_publickeybytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_secretkeybytes | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | val crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} | let crypto_secretkeybytes :r:size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
normalize_term (crypto_secretkeybytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 51,
"end_line": 29,
"start_col": 0,
"start_line": 28
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_secretkeybytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTyp... | [] | false | false | false | false | false | let crypto_secretkeybytes:r: size_t{v r == FP.crypto_secretkeybytes FP.Frodo64} =
| normalize_term (crypto_secretkeybytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_dec | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_dec: crypto_kem_dec_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_dec ss ct sk =
crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 45,
"start_col": 0,
"start_line": 44
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Frodo.KEM.crypto_kem_dec_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Hacl.Impl.Frodo.Params.crypto_secretkeybytes",
"Hacl.Frodo.KEM.crypto_kem_dec",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_dec ss ct sk =
| crypto_kem_dec FP.Frodo64 FP.SHAKE128 ss ct sk | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_ciphertextbytes | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | val crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} | let crypto_ciphertextbytes :r:size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
normalize_term (crypto_ciphertextbytes FP.Frodo64) | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 52,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | r:
Lib.IntTypes.int_t Lib.IntTypes.U32 Lib.IntTypes.PUB
{Lib.IntTypes.v r == Spec.Frodo.Params.crypto_ciphertextbytes Spec.Frodo.Params.Frodo64} | Prims.Tot | [
"total"
] | [] | [
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Lib.IntTypes.range",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTyp... | [] | false | false | false | false | false | let crypto_ciphertextbytes:r: size_t{v r == FP.crypto_ciphertextbytes FP.Frodo64} =
| normalize_term (crypto_ciphertextbytes FP.Frodo64) | false |
Hacl.Frodo64.fst | Hacl.Frodo64.crypto_kem_enc | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | val crypto_kem_enc: crypto_kem_enc_st FP.Frodo64 FP.SHAKE128 | let crypto_kem_enc ct ss pk =
crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | {
"file_name": "code/frodo/Hacl.Frodo64.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 41,
"start_col": 0,
"start_line": 40
} | module Hacl.Frodo64
open FStar.HyperStack
open FStar.HyperStack.ST
open Lib.IntTypes
open Lib.Buffer
open Hacl.Frodo.KEM
open Hacl.Impl.Frodo.Params
module FP = Spec.Frodo.Params
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
[@@ CPrologue
"/*
this variant is used only for testing purposes!
*/\n" ]
let crypt... | {
"checked_file": "/",
"dependencies": [
"Spec.Frodo.Params.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.Frodo.Params.fst.checked",
"Hacl.Frodo.KEM.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checke... | [
{
"abbrev": true,
"full_module": "Spec.Frodo.Params",
"short_module": "FP"
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Frodo.Params",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Frodo.KEM",
"short_module": null
},
{
"abbrev": false,
"fu... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Hacl.Frodo.KEM.crypto_kem_enc_st Spec.Frodo.Params.Frodo64 Spec.Frodo.Params.SHAKE128 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Matrix.lbytes",
"Hacl.Impl.Frodo.Params.crypto_ciphertextbytes",
"Spec.Frodo.Params.Frodo64",
"Hacl.Impl.Frodo.Params.crypto_bytes",
"Hacl.Impl.Frodo.Params.crypto_publickeybytes",
"Hacl.Frodo.KEM.crypto_kem_enc",
"Spec.Frodo.Params.SHAKE128",
"Lib.IntTypes.uint32"
] | [] | false | false | false | true | false | let crypto_kem_enc ct ss pk =
| crypto_kem_enc FP.Frodo64 FP.SHAKE128 ct ss pk | false |
Lib.Exponentiation.fst | Lib.Exponentiation.b_acc | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | val b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat | let b_acc (l:pos) (bBits:nat) (b:nat{b < pow2 bBits}) (i:nat{i <= bBits / l}) : nat =
b / pow2 (bBits - bBits % l - l * i) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 23,
"start_col": 0,
"start_line": 22
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
l: Prims.pos ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits / l}
-> Prims.nat | Prims.Tot | [
"total"
] | [] | [
"Prims.pos",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"FStar.Mul.op_Star"
] | [] | false | false | false | false | false | let b_acc (l: pos) (bBits: nat) (b: nat{b < pow2 bBits}) (i: nat{i <= bBits / l}) : nat =
| b / pow2 (bBits - bBits % l - l * i) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_div_pow2i | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | val lemma_b_div_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b / pow2 (bBits - i) == b / pow2 (bBits - i + 1) * 2 + b / pow2 (bBits - i) % 2) | let lemma_b_div_pow2i bBits b i =
assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 47,
"start_col": 0,
"start_line": 45
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | bBits: Prims.nat -> b: Prims.nat{b < Prims.pow2 bBits} -> i: Prims.pos{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
b / Prims.pow2 (bBits - i) ==
(b / Prims.pow2 (bBits - i + 1)) * 2 + b / Prims.pow2 (bBits - i) % 2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Lib.Exponentiation.lemma_b_div_pow2ki",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int"
] | [] | true | false | true | false | false | let lemma_b_div_pow2i bBits b i =
| assert_norm (pow2 1 = 2);
lemma_b_div_pow2ki bBits b 1 i | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | val exp_lr_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_lr k a bBits b == pow k a b) | let exp_lr_lemma #t k a bBits b =
let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 151,
"start_col": 0,
"start_line": 147
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_lr k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"Lib.Exponentiat... | [] | true | false | true | false | false | let exp_lr_lemma #t k a bBits b =
| let acc = Loops.repeati bBits (exp_lr_f k a bBits b) one in
exp_lr_lemma_loop #t k a bBits b bBits;
assert (acc == pow k a (b / pow2 0));
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_rl_lemma | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | val exp_rl_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_rl k a bBits b == pow k a b) | let exp_rl_lemma #t k a bBits b =
let (acc, c) = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 96,
"start_col": 0,
"start_line": 92
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_rl k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Math.Lemmas.small_mod",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Modulus",
"Lib.Exponentiation.exp_rl_lemma_loop",
"FStar.Pervasi... | [] | false | false | true | false | false | let exp_rl_lemma #t k a bBits b =
| let acc, c = Loops.repeati bBits (exp_rl_f k bBits b) (one, a) in
exp_rl_lemma_loop k bBits b bBits a;
assert (acc == pow k a (b % pow2 bBits));
Math.Lemmas.small_mod b (pow2 bBits) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma_step | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | val exp_lr_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i < bBits}
-> acc1:t -> Lemma
(requires acc1 == pow k a (b / pow2 (bBits - i)))
(ensures exp_lr_f k a bBits b i acc1 == pow k a (b / pow2 (bBits - i - 1))) | let exp_lr_lemma_step #t k a bBits b i acc1 =
let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow ... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 120,
"start_col": 0,
"start_line": 108
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i < bBits} ->
acc1: t
-> FStar.Pervasives.Lemma
(requires acc1 == Lib.Exponentiation.Definition.pow k a (b / Prims.pow2 (bBits - i)))
(ensures
L... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.bool",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow_add",
"FStar.Mul... | [] | false | false | true | false | false | let exp_lr_lemma_step #t k a bBits b i acc1 =
| let acc = exp_lr_f k a bBits b i acc1 in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == (b / pow2 (bBits - i)) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul acc1 acc1 == pow k a ((b / pow2 (bBits - i)) * 2));
if (b / pow2 (bBits... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_lr_lemma_loop | val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i))) | val exp_lr_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma (let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
acc == pow k a (b / pow2 (bBits - i))) | let rec exp_lr_lemma_loop #t k a bBits b i =
let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0 then begin
Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
() end
else begin
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 144,
"start_col": 0,
"start_line": 130
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let acc =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_lr_f k a bBits b)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow0",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_lr_f",
... | [
"recursion"
] | false | false | true | false | false | let rec exp_lr_lemma_loop #t k a bBits b i =
| let acc = Loops.repeati i (exp_lr_f k a bBits b) one in
if i = 0
then
(Loops.eq_repeati0 i (exp_lr_f k a bBits b) one;
lemma_pow0 k a;
())
else
let acc1 = Loops.repeati (i - 1) (exp_lr_f k a bBits b) one in
Loops.unfold_repeati i (exp_lr_f k a bBits b) one (i - 1);
exp_lr_lemma_loop k a bBits b (i - 1);... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap2_lemma | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | val exp_mont_ladder_swap2_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap2 k a bBits b == exp_mont_ladder k a bBits b) | let exp_mont_ladder_swap2_lemma #t k a bBits b =
exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 55,
"end_line": 251,
"start_col": 0,
"start_line": 250
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap2 k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_mont_ladder_swap2_lemma #t k a bBits b =
| exp_mont_ladder_swap2_lemma_loop #t k a bBits b bBits | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_mod_pow2i | val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1)) | val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1)) | let lemma_b_mod_pow2i bBits b i =
calc (==) {
b % pow2 i;
(==) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
b % pow2 i / pow2 (i - 1) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
(==) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
b % pow2 i / pow2 (i - 1) * pow... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 20,
"start_col": 0,
"start_line": 11
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} -> | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | bBits: Prims.nat -> b: Prims.nat{b < Prims.pow2 bBits} -> i: Prims.pos{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
b % Prims.pow2 i == (b / Prims.pow2 (i - 1) % 2) * Prims.pow2 (i - 1) + b % Prims.pow2 (i - 1)
) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Modulus",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Preo... | [] | false | false | true | false | false | let lemma_b_mod_pow2i bBits b i =
| calc ( == ) {
b % pow2 i;
( == ) { Math.Lemmas.euclidean_division_definition (b % pow2 i) (pow2 (i - 1)) }
(b % pow2 i / pow2 (i - 1)) * pow2 (i - 1) + b % pow2 i % pow2 (i - 1);
( == ) { Math.Lemmas.pow2_modulo_modulo_lemma_1 b (i - 1) i }
(b % pow2 i / pow2 (i - 1)) * pow2 (i - 1) + b % pow2 (i - 1);
( ==... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | val exp_mont_ladder_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder k a bBits b == pow k a b) | let exp_mont_ladder_lemma # t k a bBits b =
let (r0, r1) = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 225,
"start_col": 0,
"start_line": 222
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder k a bBits b == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_mont_ladder_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Lib.LoopCombinators.repe... | [] | false | false | true | false | false | let exp_mont_ladder_lemma #t k a bBits b =
| let r0, r1 = Loops.repeati bBits (exp_mont_ladder_f k bBits b) (one, a) in
exp_mont_ladder_lemma_loop #t k bBits b a bBits;
assert_norm (pow2 0 = 1) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_rl_lemma_loop | val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i)) | val exp_rl_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits}
-> a:t ->
Lemma (let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
acc == pow k a (b % pow2 i) /\ c == pow k a (pow2 i)) | let rec exp_rl_lemma_loop #t k bBits b i a =
let (acc, c) = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
() end
else begin
let (acc1, c1) = Loops.repeati (i... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 89,
"start_col": 0,
"start_line": 59
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits} ->
a: t
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_rl_f k bBits b)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_pow1",
"Lib.Exponentiation.Definition.lemma_pow0",
"FStar.Pervasives.assert... | [
"recursion"
] | false | false | true | false | false | let rec exp_rl_lemma_loop #t k bBits b i a =
| let acc, c = Loops.repeati i (exp_rl_f k bBits b) (one, a) in
if i = 0
then
(Loops.eq_repeati0 i (exp_rl_f k bBits b) (one, a);
assert_norm (pow2 0 = 1);
lemma_pow0 k a;
lemma_pow1 k a;
())
else
let acc1, c1 = Loops.repeati (i - 1) (exp_rl_f k bBits b) (one, a) in
Loops.unfold_repeati i (exp_rl_f ... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma_step | val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul ... | val exp_mont_ladder_lemma_step:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> r0:t -> r1:t
-> i:nat{i < bBits} -> Lemma
(requires
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i)))
(ensures
(let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
r1' == mul ... | let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
let (r0', r1') = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == b / pow2 (bBits - i) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
a... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 195,
"start_col": 0,
"start_line": 166
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
a: t ->
r0: t ->
r1: t ->
i: Prims.nat{i < bBits}
-> FStar.Pervasives.Lemma
(requires
r1 == Lib.Exponentiation.Definition.mul r0 a /\
r0 == Lib.Exponentiation.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_mul_comm",
"Prims._assert",
"Prims... | [] | false | false | true | false | false | let exp_mont_ladder_lemma_step #t k bBits b a r0 r1 i =
| let r0', r1' = exp_mont_ladder_f k bBits b i (r0, r1) in
lemma_b_div_pow2i bBits b (i + 1);
assert (b / pow2 (bBits - i - 1) == (b / pow2 (bBits - i)) * 2 + b / pow2 (bBits - i - 1) % 2);
lemma_pow_add k a (b / pow2 (bBits - i)) (b / pow2 (bBits - i));
assert (mul r0 r0 == pow k a ((b / pow2 (bBits - i)) * 2));
if (b /... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_b_div_pow2ki | val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i) | val lemma_b_div_pow2ki: bBits:nat -> b:nat{b < pow2 bBits} -> k:pos -> i:pos{i <= bBits / k} ->
Lemma (b_acc k bBits b (i - 1) * pow2 k + b_acc k bBits b i % pow2 k == b_acc k bBits b i) | let lemma_b_div_pow2ki bBits b k i =
let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc (==) {
b / pow2 (bk - k * i);
(==) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
c / pow2 k * pow2 k + c % pow2 k;
(==) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * ... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 5,
"end_line": 40,
"start_col": 0,
"start_line": 27
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
k: Prims.pos ->
i: Prims.pos{i <= bBits / k}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.b_acc k bBits b (i - 1) * Prims.pow2 k +
Lib.Exponentiation.b_acc k bBits b i % Prims.pow2 k ==
Lib.Exponentiation.b_acc k... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.eq2",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.op_Addition",
"Prims.op_Modulus",
"Prims.Cons",
"FStar.Preo... | [] | false | false | true | false | false | let lemma_b_div_pow2ki bBits b k i =
| let bk = bBits - bBits % k in
let c = b / pow2 (bk - k * i) in
calc ( == ) {
b / pow2 (bk - k * i);
( == ) { Math.Lemmas.euclidean_division_definition c (pow2 k) }
(c / pow2 k) * pow2 k + c % pow2 k;
( == ) { Math.Lemmas.division_multiplication_lemma b (pow2 (bk - k * i)) (pow2 k) }
(b / (pow2 (bk - k * i) * ... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap2_lemma_loop | val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 ... | val exp_mont_ladder_swap2_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1) = Loops.repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) in
let (r3, r4) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r0 == r3 ... | let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 247,
"start_col": 0,
"start_line": 238
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_swap2_f k bBit... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.Native.tuple2",
"Lib.Exponentiation.exp_mont_ladder_f",
"... | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_swap2_lemma_loop #t k a bBits b i =
| if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_swap2_f k bBits b) (one, a);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
())
else
(Loops.unfold_repeati i (exp_mont_ladder_swap2_f k bBits b) (one, a) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (one, a) (i - 1);
e... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_lemma_loop | val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i))) | val exp_mont_ladder_lemma_loop:
#t:Type -> k:comm_monoid t
-> bBits:nat -> b:nat{b < pow2 bBits}
-> a:t -> i:nat{i <= bBits} ->
Lemma (let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
r1 == mul r0 a /\ r0 == pow k a (b / pow2 (bBits - i))) | let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
let (r0, r1) = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one; ... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 219,
"start_col": 0,
"start_line": 205
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
a: t ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
(Lib.Exponentiation.exp_mont_ladder_f k bBits b)
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_mul_comm",
"Lib.Exponentiation.Definition.one",
"Lib.Exponentiation.Definit... | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_lemma_loop #t k bBits b a i =
| let r0, r1 = Loops.repeati i (exp_mont_ladder_f k bBits b) (one, a) in
if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (one, a);
Math.Lemmas.small_div b (pow2 bBits);
lemma_pow0 k a;
lemma_one a;
lemma_mul_comm a one;
())
else
let r0', r1' = Loops.repeati (i - 1) (exp_mont_ladde... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop | val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mo... | val exp_mont_ladder_swap_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> sw0:nat{sw0 == b / pow2 bBits % 2}
-> i:nat{i <= bBits} ->
Lemma
(let (r0, r1, sw) = Loops.repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) in
let (r3, r4) = Loops.repeati i (exp_mo... | let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
if i = 0 then begin
Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
() end
else begin
Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (o... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 274,
"start_col": 0,
"start_line": 265
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
sw0: Prims.nat{sw0 == b / Prims.pow2 bBits % 2} ->
i: Prims.nat{i <= bBits}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Lib.LoopCombinators.repeati i
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Division",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.unit",
"Lib.LoopCombinators.eq_repeati0",
"FStar.Pervasives.N... | [
"recursion"
] | false | false | true | false | false | let rec exp_mont_ladder_swap_lemma_loop #t k a bBits b sw0 i =
| if i = 0
then
(Loops.eq_repeati0 i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0);
Loops.eq_repeati0 i (exp_mont_ladder_f k bBits b) (cswap sw0 one a);
())
else
(Loops.unfold_repeati i (exp_mont_ladder_swap_f k bBits b) (one, a, sw0) (i - 1);
Loops.unfold_repeati i (exp_mont_ladder_f k bBits b) (cswap... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_pow2_loop_lemma | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | val exp_pow2_loop_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat -> i:nat{i <= b} ->
Lemma (Loops.repeat i (sqr k) a == pow k a (pow2 i)) | let rec exp_pow2_loop_lemma #t k a b i =
if i = 0 then begin
Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a end
else begin
Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_d... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 294,
"start_col": 0,
"start_line": 284
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat -> i: Prims.nat{i <= b}
-> FStar.Pervasives.Lemma
(ensures
Lib.LoopCombinators.repeat i (Lib.Exponentiation.Definition.sqr k) a ==
Lib.Exponentiation.Definition.pow k a (Prims.pow2 i)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Equality",
"Prims.int",
"Lib.Exponentiation.Definition.lemma_pow1",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Lib.LoopCombinators.eq_repeat0",
"Lib.Exponentiation.Def... | [
"recursion"
] | false | false | true | false | false | let rec exp_pow2_loop_lemma #t k a b i =
| if i = 0
then
(Loops.eq_repeat0 (sqr k) a;
assert_norm (pow2 0 = 1);
lemma_pow1 k a)
else
(Loops.unfold_repeat b (sqr k) a (i - 1);
exp_pow2_loop_lemma k a b (i - 1);
lemma_pow_add k a (pow2 (i - 1)) (pow2 (i - 1));
Math.Lemmas.pow2_double_sum (i - 1);
()) | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_mont_ladder_swap_lemma | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | val exp_mont_ladder_swap_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} ->
Lemma (exp_mont_ladder_swap k a bBits b == exp_mont_ladder k a bBits b) | let exp_mont_ladder_swap_lemma #t k a bBits b =
exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 278,
"start_col": 0,
"start_line": 277
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_mont_ladder_swap k a bBits b ==
Lib.Exponentiation.exp_mont_ladder k a bBits b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Lib.Exponentiation.exp_mont_ladder_swap_lemma_loop",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_mont_ladder_swap_lemma #t k a bBits b =
| exp_mont_ladder_swap_lemma_loop #t k a bBits b 0 bBits | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_pow2_lemma | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | val exp_pow2_lemma: #t:Type -> k:comm_monoid t -> a:t -> b:nat ->
Lemma (exp_pow2 k a b == pow k a (pow2 b)) | let exp_pow2_lemma #t k a b = exp_pow2_loop_lemma k a b b | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 57,
"end_line": 296,
"start_col": 0,
"start_line": 296
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a: t -> b: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_pow2 k a b == Lib.Exponentiation.Definition.pow k a (Prims.pow2 b)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Lib.Exponentiation.exp_pow2_loop_lemma",
"Prims.unit"
] | [] | true | false | true | false | false | let exp_pow2_lemma #t k a b =
| exp_pow2_loop_lemma k a b b | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | val exp_fw_lemma: #t:Type -> k:comm_monoid t -> a:t -> bBits:nat -> b:nat{b < pow2 bBits} -> l:pos ->
Lemma (exp_fw k a bBits b l == pow k a b) | let exp_fw_lemma #t k a bBits b l =
let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 404,
"start_col": 0,
"start_line": 393
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures Lib.Exponentiation.exp_fw k a bBits b l == Lib.Exponentiation.Definition.pow k a b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"... | [] | false | false | true | false | false | let exp_fw_lemma #t k a bBits b l =
| let b_rem = b_acc l bBits b 0 in
let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
exp_fw_acc0_aux_lemma k a bBits b l;
assert (acc0 == pow k a b_rem);
let res = Loops.repeati (bBits / l) (exp_fw_f k a bBits b l) acc0 in
exp_fw_lemma_loop k a bBits b l (bBits / l);
assert (res == pow k a (b_acc l b... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma_loop | val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i)) | val exp_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
acc == pow k a (b_acc l bBits b i)) | let rec exp_fw_lemma_loop #t k a bBits b l i =
let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else begin
Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loop... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 351,
"start_col": 0,
"start_line": 340
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.nat{i <= bBits / l}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 = Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b_acc l bBits b 0... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_fw_f",
"Prims.bool",
"Prims.u... | [
"recursion"
] | false | false | true | false | false | let rec exp_fw_lemma_loop #t k a bBits b l i =
| let acc0 = pow k a (b_acc l bBits b 0) in
let acc = Loops.repeati i (exp_fw_f k a bBits b l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_fw_f k a bBits b l) acc0
else
(Loops.unfold_repeati i (exp_fw_f k a bBits b l) acc0 (i - 1);
let acc1 = Loops.repeati (i - 1) (exp_fw_f k a bBits b l) acc0 in
assert (acc... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_KeyExpansionRound | val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool | val va_codegen_success_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_pbool | let va_codegen_success_KeyExpansionRound round rcon =
(va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_pbool_and
(va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1)... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 84,
"end_line": 48,
"start_col": 0,
"start_line": 37
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | round: Vale.X64.Memory.nat64 -> rcon: Vale.X64.Memory.nat8 -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsAes.va_codegen_success_AESNI_keygen_assist",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.InsVector.va_codegen_success_Pshufd",
"Vale.X64.InsVector.va_codegen_success_VPslldq4",
"Vale.X64.InsVector.va_codegen_suc... | [] | false | false | false | true | false | let va_codegen_success_KeyExpansionRound round rcon =
| (va_pbool_and (va_codegen_success_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_pbool_and (va_codegen_success_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255)
(va_pbool_and (va_codegen_success_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_pbool_and (va_codegen_success_Pxor... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | val exp_double_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (exp_double_fw k a1 bBits b1 a2 b2 l == mul (pow k a1 b1) (pow k a2 b2)) | let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 529,
"start_col": 0,
"start_line": 521
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_double_fw k a1 bBits b1 a2 b2 l ==
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.Exponentiation.exp_double_fw_lemma_loop... | [] | false | false | true | false | false | let exp_double_fw_lemma #t k a1 bBits b1 a2 b2 l =
| let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l;
assert (acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)));
let res = Loops.repeati (bBits / l) (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
exp_double_fw... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_mul_assoc4 | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | val lemma_mul_assoc4: #t:Type -> k:comm_monoid t -> a1:t -> a2:t -> a3:t -> a4:t ->
Lemma (k.mul a1 (k.mul (k.mul a2 a3) a4) == k.mul (k.mul (k.mul a1 a2) a3) a4) | let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
calc (==) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
(==) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
(==) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 543,
"start_col": 0,
"start_line": 536
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | k: Lib.Exponentiation.Definition.comm_monoid t -> a1: t -> a2: t -> a3: t -> a4: t
-> FStar.Pervasives.Lemma
(ensures
Mkcomm_monoid?.mul k a1 (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a2 a3) a4) ==
Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k (Mkcomm_monoid?.mul k a1 a2) a3) a4) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Lib... | [] | false | false | true | false | false | let lemma_mul_assoc4 #t k a1 a2 a3 a4 =
| calc ( == ) {
k.mul a1 (k.mul (k.mul a2 a3) a4);
( == ) { k.lemma_mul_assoc a1 (k.mul a2 a3) a4 }
k.mul (k.mul a1 (k.mul a2 a3)) a4;
( == ) { k.lemma_mul_assoc a1 a2 a3 }
k.mul (k.mul (k.mul a1 a2) a3) a4;
} | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_acc0_lemma | val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bB... | val exp_double_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits} -> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_double_fw_acc0 k a1 bBits b1 a2 b2 l in
acc0 == mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bB... | let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
let bk = bBits - bBits % l in
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 (bBits / l * l) == 0);
assert (b2 / pow2 (bBits / l * l) == 0);
lemma_p... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 44,
"end_line": 518,
"start_col": 0,
"start_line": 503
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| t... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.mul",
"Lib.Exponentiation.Definition.pow",... | [] | false | false | true | false | false | let exp_double_fw_acc0_lemma #t k a1 bBits b1 a2 b2 l =
| let bk = bBits - bBits % l in
if bBits % l = 0
then
let acc = one in
assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
assert (b1 / pow2 ((bBits / l) * l) == 0);
assert (b2 / pow2 ((bBits / l) * l) == 0);
lemma_pow0 k a1;
lemma_pow0 k a2;
lemma_one k.one;
assert (acc == mul (po... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_lemma_step | val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i)) | val exp_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc1:t -> Lemma
(requires acc1 == pow k a (b_acc l bBits b (i - 1)))
(ensures exp_fw_f k a bBits b l (i - 1) acc1 == pow k a (b_acc l bBits b i)) | let exp_fw_lemma_step #t k a bBits b l i acc1 =
let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc ... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 328,
"start_col": 0,
"start_line": 309
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.pos{i <= bBits / l} ->
acc1: t
-> FStar.Pervasives.Lemma
(requires
acc1 == Lib.Exponentiation.Definition.pow k a (Lib.Exponentiation.b... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.D... | [] | false | false | true | false | false | let exp_fw_lemma_step #t k a bBits b l i acc1 =
| let acc = exp_fw_f k a bBits b l (i - 1) acc1 in
exp_pow2_lemma k acc1 l;
let r1 = b_acc l bBits b (i - 1) in
let r2 = b_acc l bBits b i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
assert (acc == k.mul (pow k acc1 (pow2 l)) (pow k a r2));
calc ( == ) {
k.mul (pow k acc1 (pow2 l)) (pow k a r2);
( == ) { ... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.lemma_pow_distr_mul | val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x) | val lemma_pow_distr_mul: #t:Type -> k:comm_monoid t -> x:t -> a:t -> r1:nat -> r2:nat -> r3:nat ->
Lemma (k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2) == k.mul (pow k a (r1 * r3 + r2)) x) | let lemma_pow_distr_mul #t k x a r1 r2 r3 =
calc (==) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
(==) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
(==) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 423,
"start_col": 0,
"start_line": 412
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
x: t ->
a: t ->
r1: Prims.nat ->
r2: Prims.nat ->
r3: Prims.nat
-> FStar.Pervasives.Lemma
(ensures
Mkcomm_monoid?.mul k
(Mkcomm_monoid?.mul k
x
(Lib.Exponentiation.Definition.pow k (Lib.Exponentiation.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
... | [] | false | false | true | false | false | let lemma_pow_distr_mul #t k x a r1 r2 r3 =
| calc ( == ) {
k.mul (k.mul x (pow k (pow k a r1) r3)) (pow k a r2);
( == ) { lemma_pow_mul k a r1 r3 }
k.mul (k.mul x (pow k a (r1 * r3))) (pow k a r2);
( == ) { k.lemma_mul_assoc x (pow k a (r1 * r3)) (pow k a r2) }
k.mul x (k.mul (pow k a (r1 * r3)) (pow k a r2));
( == ) { lemma_pow_add k a (r1 * r3) r2 }... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_acc0_lemma | val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits ... | val exp_four_fw_acc0_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits} -> l:pos ->
Lemma
(let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits ... | let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0 then begin
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBi... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 42,
"end_line": 755,
"start_col": 0,
"start_line": 718
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Lib.Exponentiation.Definition.lemma_one",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__one"... | [] | false | false | true | false | false | let exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
| let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
if bBits % l = 0
then
(assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b1 (pow2 bBits);
Math.Lemmas.small_div b2 (pow2 bBits);
Math.Lemmas.small_div b3 (pow2... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_acc0_aux_lemma | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | val exp_fw_acc0_aux_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos ->
Lemma (let acc0 = if bBits % l = 0 then one else exp_fw_acc0 k a bBits b l in
acc0 == pow k a (b_acc l bBits b 0)) | let exp_fw_acc0_aux_lemma #t k a bBits b l =
if bBits % l = 0 then begin
let acc = one in
assert (bBits / l * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 (bBits / l * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 (bBits / l * l)));
() end
else
exp... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 38,
"end_line": 390,
"start_col": 0,
"start_line": 380
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
(match bBits % l = 0 with
| true -> Lib.Exponentiation.Definition.one
| _ -> ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Mul.op... | [] | false | false | true | false | false | let exp_fw_acc0_aux_lemma #t k a bBits b l =
| if bBits % l = 0
then
let acc = one in
assert ((bBits / l) * l == bBits);
Math.Lemmas.small_div b (pow2 bBits);
assert (b / pow2 ((bBits / l) * l) == 0);
lemma_pow0 k a;
assert (acc == pow k a (b / pow2 ((bBits / l) * l)));
()
else exp_fw_acc0_lemma #t k a bBits b l | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma_loop | val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_do... | val exp_double_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_do... | let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0 then
Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else begin... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 494,
"start_col": 0,
"start_line": 483
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.nat{i <= bBits / l}
-> FStar.Pervasives.Lemma
(ensures
(let acc0 =
Lib.E... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_double_fw_f",
"Prims.bool",
"... | [
"recursion"
] | false | false | true | false | false | let rec exp_double_fw_lemma_loop #t k a1 bBits b1 a2 b2 l i =
| let acc0 = mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)) in
let acc = Loops.repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0
else
(Loops.unfold_repeati i (exp_double_fw_f k a1 bBits b1 a2 b2 l) acc0 (i - 1);
... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansionRound | val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code | val va_code_KeyExpansionRound : round:nat64 -> rcon:nat8 -> Tot va_code | let va_code_KeyExpansionRound round rcon =
(va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255) (va_CCons (va_code_VPslldq4
(va_op_xmm_xmm 3) (va_op_xmm_xmm 1)) (va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (v... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 48,
"end_line": 33,
"start_col": 0,
"start_line": 24
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | round: Vale.X64.Memory.nat64 -> rcon: Vale.X64.Memory.nat8 -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsAes.va_code_AESNI_keygen_assist",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.InsVector.va_code_Pshufd",
"Vale.X64.InsVector.va_code_VPslldq4",
"Vale.X64.InsVector.va_code_Pxor",
"Vale... | [] | false | false | false | true | false | let va_code_KeyExpansionRound round rcon =
| (va_Block (va_CCons (va_code_AESNI_keygen_assist (va_op_xmm_xmm 2) (va_op_xmm_xmm 1) rcon)
(va_CCons (va_code_Pshufd (va_op_xmm_xmm 2) (va_op_xmm_xmm 2) 255)
(va_CCons (va_code_VPslldq4 (va_op_xmm_xmm 3) (va_op_xmm_xmm 1))
(va_CCons (va_code_Pxor (va_op_xmm_xmm 1) (va_op_xmm_xmm 3))
... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_lemma | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow ... | val exp_four_fw_lemma: #t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos ->
Lemma (exp_four_fw k a1 bBits b1 a2 b2 a3 b3 a4 b4 l ==
mul (mul (mul (pow k a1 b1) (pow ... | let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 =
if bBits % l = 0 then one
else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
ex... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 26,
"end_line": 780,
"start_col": 0,
"start_line": 758
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Lib.Exponentiation.exp_four_fw_lemma_loop",
"Prims.op_Division",
"Lib.LoopCombinators.repeat... | [] | false | false | true | false | false | let exp_four_fw_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l =
| let b1_rem = b_acc l bBits b1 0 in
let b2_rem = b_acc l bBits b2 0 in
let b3_rem = b_acc l bBits b3 0 in
let b4_rem = b_acc l bBits b4 0 in
let acc0 = if bBits % l = 0 then one else exp_four_fw_acc0 k a1 bBits b1 a2 b2 a3 b3 a4 b4 l in
exp_four_fw_acc0_lemma #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l;
assert (acc0 ==
mul... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_fw_acc0_lemma | val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0)) | val exp_fw_acc0_lemma:
#t:Type -> k:comm_monoid t
-> a:t -> bBits:nat -> b:nat{b < pow2 bBits}
-> l:pos{bBits % l <> 0} ->
Lemma (exp_fw_acc0 k a bBits b l == pow k a (b_acc l bBits b 0)) | let exp_fw_acc0_lemma #t k a bBits b l =
let bits_c = get_ith_lbits bBits b (bBits / l * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 (bBits / l * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits (bBits / l * l);
assert (b / pow2 (bBits / l * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_c... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 370,
"start_col": 0,
"start_line": 360
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a: t ->
bBits: Prims.nat ->
b: Prims.nat{b < Prims.pow2 bBits} ->
l: Prims.pos{bBits % l <> 0}
-> FStar.Pervasives.Lemma
(ensures
Lib.Exponentiation.exp_fw_acc0 k a bBits b l ==
Lib.Exponentiation.Definition.pow k a (Lib.Exponentia... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_disEquality",
"Prims.int",
"Prims.op_Modulus",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.Exponentiation.Definition.pow",
"Prims.op_Division",
"FStar.Mul... | [] | true | false | true | false | false | let exp_fw_acc0_lemma #t k a bBits b l =
| let bits_c = get_ith_lbits bBits b ((bBits / l) * l) l in
let acc = pow k a bits_c in
assert (bits_c == b / pow2 ((bBits / l) * l) % pow2 l);
Math.Lemmas.lemma_div_lt_nat b bBits ((bBits / l) * l);
assert (b / pow2 ((bBits / l) * l) < pow2 (bBits % l));
Math.Lemmas.pow2_lt_compat l (bBits % l);
Math.Lemmas.small_mod (b... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansion128Stdcall | val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code | val va_code_KeyExpansion128Stdcall : win:bool -> Tot va_code | let va_code_KeyExpansion128Stdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 14,
"end_line": 308,
"start_col": 0,
"start_line": 298
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | win: Prims.bool -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRcx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.... | [] | false | false | false | true | false | let va_code_KeyExpansion128Stdcall win =
| (va_Block (va_CCons (if win
then
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx)
0
Secret)
(va_CNil ()))
else
... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_KeyExpansion128Stdcall | val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool | val va_codegen_success_KeyExpansion128Stdcall : win:bool -> Tot va_pbool | let va_codegen_success_KeyExpansion128Stdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 1) (va_op_reg_opr64_reg64 rRcx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet
... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 85,
"end_line": 322,
"start_col": 0,
"start_line": 311
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | win: Prims.bool -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRcx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_ttrue... | [] | false | false | false | true | false | let va_codegen_success_KeyExpansion128Stdcall win =
| (va_pbool_and (if win
then
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 1)
(va_op_reg_opr64_reg64 rRcx)
0
Secret)
(va_ttrue ())
else
va_pbool_and (va_codegen_success_Load128_buff... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptRound | val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool | val va_codegen_success_AES128EncryptRound : n:nat -> Tot va_pbool | let va_codegen_success_AES128EncryptRound n =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_pbool_and
(va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ()))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 86,
"end_line": 434,
"start_col": 0,
"start_line": 431
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Prims.op_Multiply",
"Vale.Arch.HeapTypes_s.Secret",
"Va... | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptRound n =
| (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` n)
Secret)
(va_pbool_and (va_codegen_success_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_ttrue ()))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptRound | val va_code_AES128EncryptRound : n:nat -> Tot va_code | val va_code_AES128EncryptRound : n:nat -> Tot va_code | let va_code_AES128EncryptRound n =
(va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) (16 `op_Multiply` n) Secret) (va_CCons (va_code_AESNI_enc
(va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ())))) | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 427,
"start_col": 0,
"start_line": 424
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.nat -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Prims.op_Multiply",
"Vale.Arch.HeapTypes_s.... | [] | false | false | false | true | false | let va_code_AES128EncryptRound n =
| (va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
(16 `op_Multiply` n)
Secret)
(va_CCons (va_code_AESNI_enc (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CNil ())))) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptBlock | val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code | val va_code_AES128EncryptBlock : va_dummy:unit -> Tot va_code | let va_code_AES128EncryptBlock () =
(va_Block (va_CCons (va_Block (va_CNil ())) (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2) (va_op_reg_opr64_reg64 rR8) 0 Secret) (va_CCons
(va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2)) (va_CCons (va_code_AES128EncryptRound 1)
(va_... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 533,
"start_col": 0,
"start_line": 522
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.Decls.va_CNil",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.Arch.HeapTy... | [] | false | false | false | true | false | let va_code_AES128EncryptBlock () =
| (va_Block (va_CCons (va_Block (va_CNil ()))
(va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
0
Secret)
(va_CCons (va_code_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2))
... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_four_fw_lemma_loop | val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mu... | val exp_four_fw_lemma_loop:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> a3:t -> b3:nat{b3 < pow2 bBits}
-> a4:t -> b4:nat{b4 < pow2 bBits}
-> l:pos -> i:nat{i <= bBits / l} ->
Lemma (
let acc0 =
mul
(mul
(mu... | let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
let acc0 =
mul
(mul
(mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0)) in
let acc = Loops.repeati i (exp_four_fw_f k... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 10,
"end_line": 697,
"start_col": 0,
"start_line": 681
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
a3: t ->
b3: Prims.nat{b3 < Prims.pow2 bBits} ->
a4: t ->
b4: Prims.nat{b4 < Prims.pow2 bBits} ->
l: Prims.... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Prims.op_Equality",
"Prims.int",
"Lib.LoopCombinators.eq_repeati0",
"Lib.Exponentiation.exp_four_fw_f",
"Prims.bool",
"Pr... | [
"recursion"
] | false | false | true | false | false | let rec exp_four_fw_lemma_loop #t k a1 bBits b1 a2 b2 a3 b3 a4 b4 l i =
| let acc0 =
mul (mul (mul (pow k a1 (b_acc l bBits b1 0)) (pow k a2 (b_acc l bBits b2 0)))
(pow k a3 (b_acc l bBits b3 0)))
(pow k a4 (b_acc l bBits b4 0))
in
let acc = Loops.repeati i (exp_four_fw_f k a1 bBits b1 a2 b2 a3 b3 a4 b4 l) acc0 in
if i = 0
then Loops.eq_repeati0 i (exp_four_fw_f k a1 bBits b1 a... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptBlock | val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool | val va_codegen_success_AES128EncryptBlock : va_dummy:unit -> Tot va_pbool | let va_codegen_success_AES128EncryptBlock () =
(va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8) 0 Secret) (va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0)
(va_op_xmm_xmm 2)) (va_pbool_and (va_codegen_success_AES128EncryptRound... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 548,
"start_col": 0,
"start_line": 536
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | va_dummy: Prims.unit -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.InsVector.va_co... | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptBlock () =
| (va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 2)
(va_op_reg_opr64_reg64 rR8)
0
Secret)
(va_pbool_and (va_codegen_success_Pxor (va_op_xmm_xmm 0) (va_op_xmm_xmm 2))
(va_pbool_and (va_codegen_success_AES128EncryptRound 1)
... | false |
Lib.Exponentiation.fst | Lib.Exponentiation.exp_double_fw_lemma_step | val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
... | val exp_double_fw_lemma_step:
#t:Type -> k:comm_monoid t
-> a1:t -> bBits:nat -> b1:nat{b1 < pow2 bBits}
-> a2:t -> b2:nat{b2 < pow2 bBits}
-> l:pos -> i:pos{i <= bBits / l} -> acc:t -> Lemma
(requires
acc == mul (pow k a1 (b_acc l bBits b1 (i - 1))) (pow k a2 (b_acc l bBits b2 (i - 1))))
(ensures
... | let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1... | {
"file_name": "lib/Lib.Exponentiation.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 470,
"start_col": 0,
"start_line": 437
} | module Lib.Exponentiation
open FStar.Mul
module Loops = Lib.LoopCombinators
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val lemma_b_mod_pow2i: bBits:nat -> b:nat{b < pow2 bBits} -> i:pos{i <= bBits} ->
Lemma (b % pow2 i == b / pow2 (i - 1) % 2 * pow2 (i - 1) + b % pow2 (i - 1))
let lemma_b_mod_pow2i bBits b i... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.LoopCombinators.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"... | [
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Exponentiation.Definition",
"short_module": null
},
{
"abbrev": true,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
k: Lib.Exponentiation.Definition.comm_monoid t ->
a1: t ->
bBits: Prims.nat ->
b1: Prims.nat{b1 < Prims.pow2 bBits} ->
a2: t ->
b2: Prims.nat{b2 < Prims.pow2 bBits} ->
l: Prims.pos ->
i: Prims.pos{i <= bBits / l} ->
acc: t
-> FStar.Pervasives.Lemma
(requires
acc ==
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Lib.Exponentiation.Definition.comm_monoid",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.pos",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"FStar.Calc.calc_finish",
"Prims.eq2",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Lib.Exponentiation.D... | [] | false | false | true | false | false | let exp_double_fw_lemma_step #t k a1 bBits b1 a2 b2 l i acc =
| let acc1 = exp_pow2 k acc l in
let r11 = b_acc l bBits b1 (i - 1) in
let r12 = b_acc l bBits b1 i % pow2 l in
let r21 = b_acc l bBits b2 (i - 1) in
let r22 = b_acc l bBits b2 i % pow2 l in
Math.Lemmas.distributivity_sub_right l i 1;
let res_a1 = pow k a1 (b_acc l bBits b1 i) in
let res_a2 = pow k a2 (b_acc l bBits b2 i... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_AES128EncryptBlockStdcall | val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code | val va_code_AES128EncryptBlockStdcall : win:bool -> Tot va_code | let va_code_AES128EncryptBlockStdcall win =
(va_Block (va_CCons (if win then va_Block (va_CCons (va_code_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRdx) 0 Secret) (va_CNil
())) else va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 27,
"end_line": 639,
"start_col": 0,
"start_line": 629
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | win: Prims.bool -> Vale.X64.Decls.va_code | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Vale.X64.InsVector.va_code_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.... | [] | false | false | false | true | false | let va_code_AES128EncryptBlockStdcall win =
| (va_Block (va_CCons (if win
then
va_Block (va_CCons (va_code_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRdx)
0
Secret)
(va_CNil ()))
else
... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_codegen_success_AES128EncryptBlockStdcall | val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool | val va_codegen_success_AES128EncryptBlockStdcall : win:bool -> Tot va_pbool | let va_codegen_success_AES128EncryptBlockStdcall win =
(va_pbool_and (if win then va_pbool_and (va_codegen_success_Load128_buffer
(va_op_heaplet_mem_heaplet 0) (va_op_xmm_xmm 0) (va_op_reg_opr64_reg64 rRdx) 0 Secret)
(va_ttrue ()) else va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 652,
"start_col": 0,
"start_line": 642
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | win: Prims.bool -> Vale.X64.Decls.va_pbool | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Vale.X64.Decls.va_pbool_and",
"Vale.X64.InsVector.va_codegen_success_Load128_buffer",
"Vale.X64.Decls.va_op_heaplet_mem_heaplet",
"Vale.X64.Decls.va_op_xmm_xmm",
"Vale.X64.Decls.va_op_reg_opr64_reg64",
"Vale.X64.Machine_s.rRdx",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.va_ttrue... | [] | false | false | false | true | false | let va_codegen_success_AES128EncryptBlockStdcall win =
| (va_pbool_and (if win
then
va_pbool_and (va_codegen_success_Load128_buffer (va_op_heaplet_mem_heaplet 0)
(va_op_xmm_xmm 0)
(va_op_reg_opr64_reg64 rRdx)
0
Secret)
(va_ttrue ())
else
va_pbool_and (va_codegen_success_Load128_buff... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wp_KeyExpansionRound | val va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32))
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enabl... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 143,
"start_col": 0,
"start_line": 128
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.validDstAddrs128",
"Vale.X64.Decls.va_get_mem_heaplet",
... | [] | false | false | false | true | true | let va_wp_KeyExpansionRound
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg64 rRdx va_s0)
dst
11
(va_get_mem_layout va_s0)
Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <= round /\ round < 10) /\
rcon == Vale.AES.AES_common_s.aes_rcon round /\ Vale.AES.AES_s.is_a... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_quick_KeyExpansionRound | val va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | val va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | let va_quick_KeyExpansionRound (round:nat64) (rcon:nat8) (dst:buffer128) (key:(seq nat32)) :
(va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(va_QProc (va_code_KeyExpansionRound round rcon) ([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem]) (va_wp_KeyExpans... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 171,
"start_col": 0,
"start_line": 167
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.AES128.va_code_KeyExpansionRound round rcon) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
... | [] | false | false | false | false | false | let va_quick_KeyExpansionRound (round: nat64) (rcon: nat8) (dst: buffer128) (key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
| (va_QProc (va_code_KeyExpansionRound round rcon)
([va_Mod_flags; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; va_Mod_mem_heaplet 1; va_Mod_mem])
(va_wp_KeyExpansionRound round rcon dst key)
(va_wpProof_KeyExpansionRound round rcon dst key)) | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_qcode_KeyExpansionRound | val va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | val va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) | let va_qcode_KeyExpansionRound (va_mods:va_mods_t) (round:nat64) (rcon:nat8) (dst:buffer128)
(key:(seq nat32)) : (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
(qblock va_mods (fun (va_s:va_state) -> let (va_old_s:va_state) = va_s in va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column ... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 97,
"end_line": 81,
"start_col": 0,
"start_line": 51
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
va_mods: Vale.X64.QuickCode.va_mods_t ->
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.AES128.va_code_KeyExpansionRound round rcon) | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.QuickCode.va_mods_t",
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.QuickCodes.qblock",
"Prims.unit",
"Prims.Cons",
"Vale.X64.Decls.va_code",
"Vale.X64.InsAes.va_code_AESNI_keygen_assist",
"Vale.... | [] | false | false | false | false | false | let va_qcode_KeyExpansionRound
(va_mods: va_mods_t)
(round: nat64)
(rcon: nat8)
(dst: buffer128)
(key: (seq nat32))
: (va_quickCode unit (va_code_KeyExpansionRound round rcon)) =
| (qblock va_mods
(fun (va_s: va_state) ->
let va_old_s:va_state = va_s in
va_QSeq va_range1
"***** PRECONDITION NOT MET AT line 70 column 24 of file /home/gebner/fstar_dataset/projects/hacl-star/vale/code/crypto/aes/x64/Vale.AES.X64.AES128.vaf *****"
(va_quick_AESNI_keygen_assist ... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wpProof_KeyExpansionRound | val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -... | val va_wpProof_KeyExpansionRound : round:nat64 -> rcon:nat8 -> dst:buffer128 -> key:(seq nat32) ->
va_s0:va_state -> va_k:(va_state -> unit -> Type0)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_KeyExpansionRound round rcon dst key va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -... | let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
let (va_sM, va_f0) = va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0
round rcon dst key in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM
(va_... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 164,
"start_col": 0,
"start_line": 154
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
round: Vale.X64.Memory.nat64 ->
rcon: Vale.X64.Memory.nat8 ->
dst: Vale.X64.Memory.buffer128 ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Prims.Ghost ((Vale.X64.Decls.va_state * Vale.X64.D... | Prims.Ghost | [] | [] | [
"Vale.X64.Memory.nat64",
"Vale.X64.Memory.nat8",
"Vale.X64.Memory.buffer128",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Vale.X64.Decls.va_fuel",
"FStar.Pervasives.Native.Mktuple3",
"Vale.X64.QuickCode.va_lemma_norm_mods",
"Prims.Cons",
"Vale.X64.Q... | [] | false | false | false | false | false | let va_wpProof_KeyExpansionRound round rcon dst key va_s0 va_k =
| let va_sM, va_f0 =
va_lemma_KeyExpansionRound (va_code_KeyExpansionRound round rcon) va_s0 round rcon dst key
in
va_lemma_upd_update va_sM;
assert (va_state_eq va_sM
(va_update_flags va_sM
(va_update_xmm 3
va_sM
(va_update_xmm 2
va_sM
(va... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_wp_KeyExpansionRoundUnrolledRecursive | val va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | val va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | let va_wp_KeyExpansionRoundUnrolledRecursive (key:(seq nat32)) (dst:buffer128) (n:int)
(va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0) (va_get_reg64
rRdx va_s0) dst 11 (va_get_mem_layout va_s0) Secret /\ (aesni_enable... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 68,
"end_line": 265,
"start_col": 0,
"start_line": 248
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
dst: Vale.X64.Memory.buffer128 ->
n: Prims.int ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Prims.int",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Decls.validDstAddrs128",
"Vale.X64.Decls.va_get_mem_heaplet",
"Vale.X64.Decls.va_get_reg64",
"Va... | [] | false | false | false | true | true | let va_wp_KeyExpansionRoundUnrolledRecursive
(key: (seq nat32))
(dst: buffer128)
(n: int)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 =
| (va_get_ok va_s0 /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem_heaplet 1 va_s0)
(va_get_reg64 rRdx va_s0)
dst
11
(va_get_mem_layout va_s0)
Secret /\ (aesni_enabled /\ avx_enabled /\ sse_enabled) /\ (0 <= n /\ n <= 10) /\
Vale.AES.AES_s.is_aes_key_LE AES_128 key /\
key == Vale.Arch.Types.quad3... | false |
Vale.AES.X64.AES128.fst | Vale.AES.X64.AES128.va_code_KeyExpansionRoundUnrolledRecursive | val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n]) | val va_code_KeyExpansionRoundUnrolledRecursive : n:int -> Tot va_code(decreases %[n]) | let rec va_code_KeyExpansionRoundUnrolledRecursive n =
(va_Block (va_CCons (if (0 < n && n <= 10) then va_Block (va_CCons
(va_code_KeyExpansionRoundUnrolledRecursive (n - 1)) (va_CCons (va_code_KeyExpansionRound (n -
1) (Vale.AES.AES_common_s.aes_rcon (n - 1))) (va_CNil ()))) else va_Block (va_CNil ()))
(... | {
"file_name": "obj/Vale.AES.X64.AES128.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 18,
"end_line": 181,
"start_col": 0,
"start_line": 177
} | module Vale.AES.X64.AES128
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.AES.AES_s
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.Q... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.InsMem.fsti.checked",
"Vale.X64... | [
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | n: Prims.int -> Prims.Tot Vale.X64.Decls.va_code | Prims.Tot | [
"total",
""
] | [] | [
"Prims.int",
"Vale.X64.Decls.va_Block",
"Vale.X64.Decls.va_CCons",
"Prims.op_AmpAmp",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Vale.AES.X64.AES128.va_code_KeyExpansionRoundUnrolledRecursive",
"Prims.op_Subtraction",
"Vale.AES.X64.AES128.va_code_KeyExpansionRound",
"Vale.AES.AES_common_s.a... | [
"recursion"
] | false | false | false | true | false | let rec va_code_KeyExpansionRoundUnrolledRecursive n =
| (va_Block (va_CCons (if (0 < n && n <= 10)
then
va_Block (va_CCons (va_code_KeyExpansionRoundUnrolledRecursive (n - 1))
(va_CCons (va_code_KeyExpansionRound (n - 1)
(Vale.AES.AES_common_s.aes_rcon (n - 1)))
(va_CNil ())))
... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.