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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_hi64_properties | val lemma_hi64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern hi64 q0; hi64 q1}
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) | val lemma_hi64_properties (_:unit) : Lemma
(forall (q0 q1:quad32).{:pattern hi64 q0; hi64 q1}
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) | let lemma_hi64_properties (_:unit) :
Lemma (forall (q0 q1:quad32) . (q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1))
=
hi64_reveal ();
let helper (q0 q1:quad32) : Lemma ((q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 1 i... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 193,
"start_col": 0,
"start_line": 181
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (q0: Vale.Def.Types_s.quad32) (q1: Vale.Def.Types_s.quad32).
{:pattern Vale.Arch.Types.hi64 q0; Vale.Arch.Types.hi64 q1}
Mkfour?.hi2 q0 == Mkfour?.hi2 q1 /\ Mkfour?.hi3 q0 == Mkfour?.hi3 q1 <==>
Vale.Arch.Types.hi64 q0 == Vale.A... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_iff",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Words_s.nat64",
"Vale.Arch.Types.hi64",
"Prims.l... | [] | false | false | true | false | false | let lemma_hi64_properties (_: unit)
: Lemma
(forall (q0: quad32) (q1: quad32).
(q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) =
| hi64_reveal ();
let helper (q0 q1: quad32)
: Lemma ((q0.hi2 == q1.hi2 /\ q0.hi3 == q1.hi3) <==> (hi64 q0 == hi64 q1)) =
let Mktwo n1 n2 = two_select (four_to_two_two q0) 1 in
nat_to_two_to_nat n1 n2;
let Mktwo n1 n2 = two_select (four_to_two_two q1) 1 in
nat_to_two_to_nat n1 n2;
()
in
FStar.Classical.fora... | false |
Spec.Agile.DH.fst | Spec.Agile.DH.dh | val dh: a:algorithm -> s:scalar a -> p:serialized_point a -> Tot (option (serialized_point a)) | val dh: a:algorithm -> s:scalar a -> p:serialized_point a -> Tot (option (serialized_point a)) | let dh a s p =
match a with
| DH_Curve25519 ->
let output = Spec.Curve25519.scalarmult s p in
let is_valid = not (lbytes_eq (create (size_public a) (u8 0)) output) in
if is_valid then Some output else None
| DH_P256 ->
Spec.P256.ecdh p s | {
"file_name": "specs/Spec.Agile.DH.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 56,
"start_col": 0,
"start_line": 49
} | module Spec.Agile.DH
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
/// Constants
type algorithm =
| DH_Curve25519
| DH_P256
inline_for_extraction
let size_key (a:algorithm) : Tot size_nat =
match a with
| DH_Curve25519 -> 32
| DH_P256 -> 32
inline_for_extraction
let size_publi... | {
"checked_file": "/",
"dependencies": [
"Spec.P256.fst.checked",
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_... | [
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | a: Spec.Agile.DH.algorithm -> s: Spec.Agile.DH.scalar a -> p: Spec.Agile.DH.serialized_point a
-> FStar.Pervasives.Native.option (Spec.Agile.DH.serialized_point a) | Prims.Tot | [
"total"
] | [] | [
"Spec.Agile.DH.algorithm",
"Spec.Agile.DH.scalar",
"Spec.Agile.DH.serialized_point",
"FStar.Pervasives.Native.Some",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.op_Negation",
"Lib.ByteSequence.lbytes_eq",
"Spec.Agile.DH.size_public",
"Lib.Sequence.creat... | [] | false | false | false | false | false | let dh a s p =
| match a with
| DH_Curve25519 ->
let output = Spec.Curve25519.scalarmult s p in
let is_valid = not (lbytes_eq (create (size_public a) (u8 0)) output) in
if is_valid then Some output else None
| DH_P256 -> Spec.P256.ecdh p s | false |
Hacl.Streaming.Poly1305_32.fsti | Hacl.Streaming.Poly1305_32.free | val free : Hacl.Streaming.Functor.free_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
(FStar.Ghost.reveal (FStar.Ghost.hide ()))
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | let free = F.free (poly1305 M32) (G.hide ()) (t M32) (poly1305_key.I.s ()) | {
"file_name": "code/streaming/Hacl.Streaming.Poly1305_32.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 22,
"start_col": 0,
"start_line": 22
} | module Hacl.Streaming.Poly1305_32
module G = FStar.Ghost
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
open Hacl.Impl.Poly1305.Fields
open Hacl.Streaming.Poly1305
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
/// Type abbreviation - makes KaRaMeL use pretty names in the generated code
let... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Hacl.Streaming.Poly1305.fst.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Poly1305.fsti.checked",
"FStar.Pervasives.fsti.checked"... | [
{
"abbrev": false,
"full_module": "Hacl.Streaming.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbre... | {
"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.Streaming.Functor.free_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
(FStar.Ghost.reveal (FStar.Ghost.hide ()))
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Streaming.Functor.free",
"Prims.unit",
"Hacl.Streaming.Poly1305.poly1305",
"Hacl.Impl.Poly1305.Fields.M32",
"FStar.Ghost.hide",
"Hacl.Streaming.Poly1305.t",
"Hacl.Streaming.Interface.__proj__Stateful__item__s",
"Hacl.Streaming.Poly1305.poly1305_key"
] | [] | false | false | false | false | false | let free =
| F.free (poly1305 M32) (G.hide ()) (t M32) (poly1305_key.I.s ()) | false | |
Hacl.Streaming.Poly1305_32.fsti | Hacl.Streaming.Poly1305_32.update | val update : Hacl.Streaming.Functor.update_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
(FStar.Ghost.reveal (FStar.Ghost.hide ()))
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | let update = F.update (poly1305 M32) (G.hide ()) (t M32) (poly1305_key.I.s ()) | {
"file_name": "code/streaming/Hacl.Streaming.Poly1305_32.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 78,
"end_line": 20,
"start_col": 0,
"start_line": 20
} | module Hacl.Streaming.Poly1305_32
module G = FStar.Ghost
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
open Hacl.Impl.Poly1305.Fields
open Hacl.Streaming.Poly1305
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
/// Type abbreviation - makes KaRaMeL use pretty names in the generated code
let... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Hacl.Streaming.Poly1305.fst.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Poly1305.fsti.checked",
"FStar.Pervasives.fsti.checked"... | [
{
"abbrev": false,
"full_module": "Hacl.Streaming.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbre... | {
"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.Streaming.Functor.update_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
(FStar.Ghost.reveal (FStar.Ghost.hide ()))
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Streaming.Functor.update",
"Prims.unit",
"Hacl.Streaming.Poly1305.poly1305",
"Hacl.Impl.Poly1305.Fields.M32",
"FStar.Ghost.hide",
"Hacl.Streaming.Poly1305.t",
"Hacl.Streaming.Interface.__proj__Stateful__item__s",
"Hacl.Streaming.Poly1305.poly1305_key"
] | [] | false | false | false | false | false | let update =
| F.update (poly1305 M32) (G.hide ()) (t M32) (poly1305_key.I.s ()) | false | |
Hacl.Streaming.Poly1305_32.fsti | Hacl.Streaming.Poly1305_32.digest | val digest : Hacl.Streaming.Functor.digest_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
()
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | let digest = F.digest (poly1305 M32) () (t M32) (poly1305_key.I.s ()) | {
"file_name": "code/streaming/Hacl.Streaming.Poly1305_32.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 69,
"end_line": 21,
"start_col": 0,
"start_line": 21
} | module Hacl.Streaming.Poly1305_32
module G = FStar.Ghost
module F = Hacl.Streaming.Functor
module I = Hacl.Streaming.Interface
open Hacl.Impl.Poly1305.Fields
open Hacl.Streaming.Poly1305
#set-options "--fuel 0 --ifuel 0 --z3rlimit 100"
/// Type abbreviation - makes KaRaMeL use pretty names in the generated code
let... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Hacl.Streaming.Poly1305.fst.checked",
"Hacl.Streaming.Interface.fsti.checked",
"Hacl.Streaming.Functor.fsti.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Poly1305.fsti.checked",
"FStar.Pervasives.fsti.checked"... | [
{
"abbrev": false,
"full_module": "Hacl.Streaming.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Streaming.Interface",
"short_module": "I"
},
{
"abbre... | {
"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.Streaming.Functor.digest_st (Hacl.Streaming.Poly1305.poly1305 Hacl.Impl.Poly1305.Fields.M32)
()
(Hacl.Streaming.Poly1305.t Hacl.Impl.Poly1305.Fields.M32)
(Stateful?.s Hacl.Streaming.Poly1305.poly1305_key ()) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Streaming.Functor.digest",
"Prims.unit",
"Hacl.Streaming.Poly1305.poly1305",
"Hacl.Impl.Poly1305.Fields.M32",
"Hacl.Streaming.Poly1305.t",
"Hacl.Streaming.Interface.__proj__Stateful__item__s",
"Hacl.Streaming.Poly1305.poly1305_key"
] | [] | false | false | false | false | false | let digest =
| F.digest (poly1305 M32) () (t M32) (poly1305_key.I.s ()) | false | |
Steel.ST.HigherArray.fst | Steel.ST.HigherArray.malloc_ptr | val malloc_ptr
(#elt: Type)
(x: elt)
(n: US.t)
: STT(a: ptr elt { base_len (base a) == US.v n /\ offset a == 0 })
emp
(fun a -> pts_to (| a, Ghost.hide (US.v n) |) P.full_perm (Seq.create (US.v n) x)) | val malloc_ptr
(#elt: Type)
(x: elt)
(n: US.t)
: STT(a: ptr elt { base_len (base a) == US.v n /\ offset a == 0 })
emp
(fun a -> pts_to (| a, Ghost.hide (US.v n) |) P.full_perm (Seq.create (US.v n) x)) | let malloc_ptr
x n
=
let a = malloc0 x n in
let (| p, _ |) = a in
rewrite
(pts_to _ _ _)
(pts_to (| p, Ghost.hide (US.v n) |) _ _);
return p | {
"file_name": "lib/steel/Steel.ST.HigherArray.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 10,
"end_line": 297,
"start_col": 0,
"start_line": 289
} | (*
Copyright 2022 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Steel.ST.PCMReference.fsti.checked",
"Steel.ST.Loops.fsti.checked",
"Steel.PCMMap.fst.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Rea... | [
{
"abbrev": true,
"full_module": "Steel.PCMMap",
"short_module": "PM"
},
{
"abbrev": true,
"full_module": "FStar.Map",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "Steel.ST.PCMReference",
"short_module": "R"
},
{
"abbrev": true,
"full_module": "Ste... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: elt -> n: FStar.SizeT.t
-> Steel.ST.Effect.STT
(a:
Steel.ST.HigherArray.ptr elt
{ Steel.ST.HigherArray.base_len (Steel.ST.HigherArray.base a) == FStar.SizeT.v n /\
Steel.ST.HigherArray.offset a == 0 }) | Steel.ST.Effect.STT | [] | [] | [
"FStar.SizeT.t",
"Steel.ST.HigherArray.ptr",
"FStar.Ghost.erased",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Steel.ST.HigherArray.offset",
"FStar.Ghost.reveal",
"Steel.ST.HigherArray.base_len",
"Steel.ST.HigherArray.base",
"Steel.ST.Util.return",
"Prims.l_an... | [] | false | true | false | false | false | let malloc_ptr x n =
| let a = malloc0 x n in
let (| p , _ |) = a in
rewrite (pts_to _ _ _) (pts_to (| p, Ghost.hide (US.v n) |) _ _);
return p | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_insert_nat64_nat32s | val lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 ) | val lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 ) | let lemma_insert_nat64_nat32s (q:quad32) (n0 n1:nat32) :
Lemma ( insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 ==
Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 ==
Mkfour q.lo0 q.lo1 n0 n1 )
=
let open Vale.Def.Words.Two in
insert_nat64_reveal ();
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 165,
"start_col": 0,
"start_line": 157
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"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 | q: Vale.Def.Types_s.quad32 -> n0: Vale.Def.Words_s.nat32 -> n1: Vale.Def.Words_s.nat32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.insert_nat64 q
(Vale.Arch.Types.two_to_nat32 (Vale.Def.Words_s.Mktwo n0 n1))
0 ==
Vale.Def.Words_s.Mkfour n0 n1 (Mkfour?.hi2 q) (Mkfour?.hi3 q) /\
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Words_s.nat32",
"Prims.unit",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Words_s.four",
"Vale.Def.Types_s.nat32",
"Vale.Def.Types_s.insert_nat64",
"Vale.Arch.Types.two_to_nat32",
"Vale.Def... | [] | true | false | true | false | false | let lemma_insert_nat64_nat32s (q: quad32) (n0 n1: nat32)
: Lemma
(insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 0 == Mkfour n0 n1 q.hi2 q.hi3 /\
insert_nat64 q (two_to_nat32 (Mktwo n0 n1)) 1 == Mkfour q.lo0 q.lo1 n0 n1) =
| let open Vale.Def.Words.Two in
insert_nat64_reveal ();
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_insert_nat64_properties | val lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
[SMTPat (insert_nat64 q n)] | val lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
[SMTPat (insert_nat64 q n)] | let lemma_insert_nat64_properties (q:quad32) (n:nat64) :
Lemma ( (let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\
q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\
q'.lo1 == q.lo1))
=
insert_nat64_reveal ();
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 155,
"start_col": 0,
"start_line": 146
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"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 | q: Vale.Def.Types_s.quad32 -> n: Vale.Def.Words_s.nat64
-> FStar.Pervasives.Lemma
(ensures
(let q' = Vale.Def.Types_s.insert_nat64 q n 0 in
Mkfour?.hi2 q' == Mkfour?.hi2 q /\ Mkfour?.hi3 q' == Mkfour?.hi3 q) /\
(let q' = Vale.Def.Types_s.insert_nat64 q n 1 in
Mkfour?.lo0 q' =... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Words_s.nat64",
"Prims.unit",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.l_and",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def... | [] | true | false | true | false | false | let lemma_insert_nat64_properties (q: quad32) (n: nat64)
: Lemma
((let q' = insert_nat64 q n 0 in
q'.hi2 == q.hi2 /\ q'.hi3 == q.hi3) /\
(let q' = insert_nat64 q n 1 in
q'.lo0 == q.lo0 /\ q'.lo1 == q.lo1)) =
| insert_nat64_reveal ();
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_insrq_extrq_relations | val lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3)) | val lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3)) | let lemma_insrq_extrq_relations (x y:quad32) :
Lemma (let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3))
=
let open Vale.Def.Words.Two in
let z = insert_nat64 x (lo64 y) 0 in
insert_n... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 297,
"start_col": 0,
"start_line": 274
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_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: Vale.Def.Types_s.quad32 -> y: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(let z = Vale.Def.Types_s.insert_nat64 x (Vale.Arch.Types.lo64 y) 0 in
z == Vale.Def.Words_s.Mkfour (Mkfour?.lo0 y) (Mkfour?.lo1 y) (Mkfour?.hi2 x) (Mkfour?.hi3 x) /\
(let z = Vale.Def.Types_s.insert_... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.unit",
"Vale.Def.Words.Two.nat_to_two_to_nat",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.nat32",
"Vale.Def.Words.Two_s.two_select",
"Vale.Def.Words.Four_s.four_to_two_two",
"Prims._assert",
"Prims.eq2",
"Vale.Def.Types_s.insert_nat64_de... | [] | false | false | true | false | false | let lemma_insrq_extrq_relations (x y: quad32)
: Lemma
(let z = insert_nat64 x (lo64 y) 0 in
z == Mkfour y.lo0 y.lo1 x.hi2 x.hi3 /\
(let z = insert_nat64 x (hi64 y) 1 in
z == Mkfour x.lo0 x.lo1 y.hi2 y.hi3)) =
| let open Vale.Def.Words.Two in
let z = insert_nat64 x (lo64 y) 0 in
insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
assert (z == insert_nat64_def x (lo64_def y) 0);
let Mktwo n1 n2 = two_select (four_to_two_two y) 0 in
nat_to_two_to_nat n1 n2;
let Mktwo n1 n2 = two_select (four_to_two_two y) 1 in
nat_to_two_to_... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_seq_quad32_empty | val le_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0) | val le_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0) | let le_bytes_to_seq_quad32_empty () :
Lemma (forall s . {:pattern (length (le_bytes_to_seq_quad32 s)) } length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0)
=
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 314,
"start_col": 0,
"start_line": 310
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (s: FStar.Seq.Base.seq Vale.Def.Types_s.nat8).
{:pattern FStar.Seq.Base.length (Vale.Def.Types_s.le_bytes_to_seq_quad32 s)}
FStar.Seq.Base.length s == 0 ==>
FStar.Seq.Base.length (Vale.Def.Types_s.le_bytes_to_seq_quad32 s) == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.quad32",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.l_True",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Prims.squash",
"Prims.l_Forall",
"Pri... | [] | true | false | true | false | false | let le_bytes_to_seq_quad32_empty ()
: Lemma
(forall s. {:pattern (length (le_bytes_to_seq_quad32 s))}
length s == 0 ==> length (le_bytes_to_seq_quad32 s) == 0) =
| reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.push_pop_xmm | val push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') | val push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') | let push_pop_xmm (x y:quad32) : Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x')
=
// assert (nat_to_two 32 (hi64 x) == two_select (four_to_two_two x) 1);
insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 271,
"start_col": 0,
"start_line": 263
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Vale.Def.Types_s.quad32 -> y: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(let x' =
Vale.Def.Types_s.insert_nat64 (Vale.Def.Types_s.insert_nat64 y (Vale.Arch.Types.hi64 x) 1)
(Vale.Arch.Types.lo64 x)
0
in
x == x')) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Arch.Types.hi64_reveal",
"Vale.Arch.Types.lo64_reveal",
"Vale.Def.Types_s.insert_nat64_reveal",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Types_s.insert_nat64",
"Vale.Arch.Types.hi64",
"Vale.Arch.Types.lo64",
"Prims.Nil",
"FStar.Per... | [] | true | false | true | false | false | let push_pop_xmm (x y: quad32)
: Lemma
(let x' = insert_nat64 (insert_nat64 y (hi64 x) 1) (lo64 x) 0 in
x == x') =
| insert_nat64_reveal ();
lo64_reveal ();
hi64_reveal ();
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_equality_check_helper | val lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | val lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | let lemma_equality_check_helper (q:quad32) :
Lemma ((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF ... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 260,
"start_col": 0,
"start_line": 246
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"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 | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
(Mkfour?.lo0 q == 0 /\ Mkfour?.lo1 q == 0 ==> Vale.Arch.Types.lo64 q == 0) /\
(Prims.op_Negation (Mkfour?.lo0 q = 0) \/ Prims.op_Negation (Mkfour?.lo1 q = 0) ==>
Prims.op_Negation (Vale.Arch.Types.lo64 q = 0)) /\
(Mkfour?.hi2 ... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.l_Forall",
"Vale.Def.Words_s.two",
"Vale.Def.Words_s.nat32",
"Prims.eq2",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words.Two_s.two_to_nat",
"Vale.Def.Words.Two_s.two_to_nat_unfold",
"Vale.Arch.Types... | [] | false | false | true | false | false | let lemma_equality_check_helper (q: quad32)
: Lemma
((q.lo0 == 0 /\ q.lo1 == 0 ==> lo64 q == 0) /\
((not (q.lo0 = 0) \/ not (q.lo1 = 0)) ==> not (lo64 q = 0)) /\
(q.hi2 == 0 /\ q.hi3 == 0 ==> hi64 q == 0) /\
((~(q.hi2 = 0) \/ ~(q.hi3 = 0)) ==> ~(hi64 q = 0)) /\
(q.lo0 == 0xFFFFFFFF /\ q.... | lo64_reveal ();
hi64_reveal ();
assert (forall (x: two nat32). {:pattern (two_to_nat 32 x)}
two_to_nat 32 x == two_to_nat_unfold 32 x);
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_seq_quad32_to_bytes | val le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) | val le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) | let le_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s)
(* This expands into showing:
le_bytes_to_seq_quad32 (le_quad32_to_bytes s)
== { definition of le_bytes_to_seq_quad32 }
seq_to_seq_four_LE (seq_nat8_to_seq_nat32_LE (le_seq_quad32_to_bytes s))
=... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 380,
"start_col": 0,
"start_line": 361
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_bytes_to_seq_quad32 (Vale.Def.Types_s.le_seq_quad32_to_bytes s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_LE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.f... | [] | true | false | true | false | false | let le_bytes_to_seq_quad32_to_bytes (s: seq quad32)
: Lemma (le_bytes_to_seq_quad32 (le_seq_quad32_to_bytes s) == s) =
| reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_seq_quad32_to_bytes_reveal ();
seq_to_seq_four_to_seq_LE (seq_map (nat_to_four 8) (seq_four_to_seq_LE s));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (seq_four_to_seq_LE s);
seq_to_seq_four_to_seq_LE (s);
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_seq_quad32_to_bytes_to_seq_quad32 | val le_seq_quad32_to_bytes_to_seq_quad32 (s:seq nat8{length s % 16 = 0}) :
Lemma (le_seq_quad32_to_bytes (le_bytes_to_seq_quad32 s) == s) | val le_seq_quad32_to_bytes_to_seq_quad32 (s:seq nat8{length s % 16 = 0}) :
Lemma (le_seq_quad32_to_bytes (le_bytes_to_seq_quad32 s) == s) | let le_seq_quad32_to_bytes_to_seq_quad32 s =
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_seq_quad32_to_bytes_reveal ();
calc (==) {
le_seq_quad32_to_bytes (le_bytes_to_seq_quad32 s);
(==) { }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq_LE (seq_to_seq_four_LE (seq_nat8_to_seq_nat3... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 400,
"start_col": 0,
"start_line": 391
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s % 16 = 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_seq_quad32_to_bytes (Vale.Def.Types_s.le_bytes_to_seq_quad32 s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"FStar.Calc.calc_finish",
"Vale.Def.Types_s.nat8",
"Prims.eq2",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Pr... | [] | false | false | true | false | false | let le_seq_quad32_to_bytes_to_seq_quad32 s =
| reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_seq_quad32_to_bytes_reveal ();
calc ( == ) {
le_seq_quad32_to_bytes (le_bytes_to_seq_quad32 s);
( == ) { () }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq_LE (seq_to_seq_four_LE (seq_nat8_to_seq_nat32_LE s)));
( == ) { () }
s;
} | false |
CustomSyntax.fst | CustomSyntax.sum_spec | val sum_spec (n: nat) : GTot nat | val sum_spec (n: nat) : GTot nat | let rec sum_spec (n:nat) : GTot nat =
if n = 0 then 0 else n + sum_spec (n - 1) | {
"file_name": "share/steel/examples/pulse/CustomSyntax.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 43,
"end_line": 288,
"start_col": 0,
"start_line": 287
} | (*
Copyright 2023 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to... | {
"checked_file": "/",
"dependencies": [
"Pulse.Lib.Pervasives.fst.checked",
"prims.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "CustomSyntax.fst"
} | [
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": false,
"full_module": "Pulse.Lib.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_m... | {
"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 -> Prims.GTot Prims.nat | Prims.GTot | [
"sometrivial"
] | [] | [
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"CustomSyntax.sum_spec",
"Prims.op_Subtraction"
] | [
"recursion"
] | false | false | false | false | false | let rec sum_spec (n: nat) : GTot nat =
| if n = 0 then 0 else n + sum_spec (n - 1) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_seq_quad32_to_bytes_of_singleton | val be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) | val be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) | let be_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q)))
=
reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
four_to_seq_BE_is_seq_four_to_seq_BE q;
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 453,
"start_col": 0,
"start_line": 448
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.be_quad32_to_bytes q ==
Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE (FStar.Seq.Base.create
1
q))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.four_to_seq_BE_is_seq_four_to_seq_BE",
"FStar.Pervasives.reveal_opaque",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"FStar.Seq.Base.seq",
... | [] | true | false | true | false | false | let be_seq_quad32_to_bytes_of_singleton (q: quad32)
: Lemma (be_quad32_to_bytes q == seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (create 1 q))) =
| reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
four_to_seq_BE_is_seq_four_to_seq_BE q;
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_bytes_to_seq_quad32_empty | val be_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (be_bytes_to_seq_quad32 s)) } length s == 0 ==> length (be_bytes_to_seq_quad32 s) == 0) | val be_bytes_to_seq_quad32_empty: unit ->
Lemma (forall s . {:pattern (length (be_bytes_to_seq_quad32 s)) } length s == 0 ==> length (be_bytes_to_seq_quad32 s) == 0) | let be_bytes_to_seq_quad32_empty () :
Lemma (forall s . {:pattern (length (be_bytes_to_seq_quad32 s)) } length s == 0 ==> length (be_bytes_to_seq_quad32 s) == 0)
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 320,
"start_col": 0,
"start_line": 316
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (s: FStar.Seq.Base.seq Vale.Def.Types_s.nat8).
{:pattern FStar.Seq.Base.length (Vale.Def.Types_s.be_bytes_to_seq_quad32 s)}
FStar.Seq.Base.length s == 0 ==>
FStar.Seq.Base.length (Vale.Def.Types_s.be_bytes_to_seq_quad32 s) == 0) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.quad32",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.l_True",
"Vale.Def.Types_s.be_bytes_to_seq_quad32",
"Prims.squash",
"Prims.l_Forall",
"Pri... | [] | true | false | true | false | false | let be_bytes_to_seq_quad32_empty ()
: Lemma
(forall s. {:pattern (length (be_bytes_to_seq_quad32 s))}
length s == 0 ==> length (be_bytes_to_seq_quad32 s) == 0) =
| reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_seq_quad32_to_bytes_injective | val le_seq_quad32_to_bytes_injective (b b':Seq.seq quad32) : Lemma
(requires Seq.equal (le_seq_quad32_to_bytes b) (le_seq_quad32_to_bytes b'))
(ensures b == b') | val le_seq_quad32_to_bytes_injective (b b':Seq.seq quad32) : Lemma
(requires Seq.equal (le_seq_quad32_to_bytes b) (le_seq_quad32_to_bytes b'))
(ensures b == b') | let le_seq_quad32_to_bytes_injective (b b':seq quad32) =
le_seq_quad32_to_bytes_reveal ();
seq_four_to_seq_LE_injective nat8;
nat_to_four_8_injective();
seq_map_injective (nat_to_four 8) (seq_four_to_seq_LE b) (seq_four_to_seq_LE b');
seq_four_to_seq_LE_injective_specific b b';
assert (equal b b') | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 515,
"start_col": 0,
"start_line": 509
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | b: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> b': FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.equal (Vale.Def.Types_s.le_seq_quad32_to_bytes b)
(Vale.Def.Types_s.le_seq_quad32_to_bytes b')) (ensures b == b') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.unit",
"Vale.Def.Words.Seq.seq_four_to_seq_LE_injective_specific",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_injective",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale... | [] | true | false | true | false | false | let le_seq_quad32_to_bytes_injective (b b': seq quad32) =
| le_seq_quad32_to_bytes_reveal ();
seq_four_to_seq_LE_injective nat8;
nat_to_four_8_injective ();
seq_map_injective (nat_to_four 8) (seq_four_to_seq_LE b) (seq_four_to_seq_LE b');
seq_four_to_seq_LE_injective_specific b b';
assert (equal b b') | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_seq_quad32_to_bytes_of_singleton | val le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) | val le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) | let le_seq_quad32_to_bytes_of_singleton (q:quad32) :
Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q))
=
le_seq_quad32_to_bytes_reveal ();
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
four_to_seq_LE_is_seq_four_to_seq_LE q;
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 446,
"start_col": 0,
"start_line": 440
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_quad32_to_bytes q ==
Vale.Def.Types_s.le_seq_quad32_to_bytes (FStar.Seq.Base.create 1 q)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.four_to_seq_LE_is_seq_four_to_seq_LE",
"Vale.Def.Types_s.nat32",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Prims.l_True",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.le... | [] | true | false | true | false | false | let le_seq_quad32_to_bytes_of_singleton (q: quad32)
: Lemma (le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)) =
| le_seq_quad32_to_bytes_reveal ();
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
four_to_seq_LE_is_seq_four_to_seq_LE q;
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_quad32_to_bytes_injective_specific | val be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | val be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | let be_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
=
be_quad32_to_bytes_injective() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 507,
"start_col": 0,
"start_line": 504
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | b: Vale.Def.Types_s.quad32 -> b': Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.be_quad32_to_bytes b == Vale.Arch.Types.be_quad32_to_bytes b' ==> b == b') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.be_quad32_to_bytes_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let be_quad32_to_bytes_injective_specific (b b': quad32)
: Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
| be_quad32_to_bytes_injective () | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_quad32_to_bytes_injective_specific | val le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | val le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | let le_quad32_to_bytes_injective_specific (b b':quad32) :
Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
=
le_quad32_to_bytes_injective() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 502,
"start_col": 0,
"start_line": 499
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | b: Vale.Def.Types_s.quad32 -> b': Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_quad32_to_bytes b == Vale.Def.Types_s.le_quad32_to_bytes b' ==> b == b') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Arch.Types.le_quad32_to_bytes_injective",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let le_quad32_to_bytes_injective_specific (b b': quad32)
: Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
| le_quad32_to_bytes_injective () | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_bytes_to_seq_quad32_to_bytes | val be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) | val be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) | let be_bytes_to_seq_quad32_to_bytes (s:seq quad32) :
Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s)
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (seq_four_to_seq_BE s));
seq_map_inverses (nat_to_fou... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 389,
"start_col": 0,
"start_line": 382
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.be_bytes_to_seq_quad32 (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
s)) ==
s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_seq_four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.f... | [] | true | false | true | false | false | let be_bytes_to_seq_quad32_to_bytes (s: seq quad32)
: Lemma (be_bytes_to_seq_quad32 (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) == s) =
| reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (seq_four_to_seq_BE s));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (seq_four_to_seq_BE s);
seq_to_seq_four_to_seq_BE (s);
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_nat64_to_bytes | val le_bytes_to_nat64_to_bytes (s:nat64) :
Lemma (le_bytes_to_nat64 (le_nat64_to_bytes s) == s) | val le_bytes_to_nat64_to_bytes (s:nat64) :
Lemma (le_bytes_to_nat64 (le_nat64_to_bytes s) == s) | let le_bytes_to_nat64_to_bytes s =
le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 303,
"start_col": 0,
"start_line": 301
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_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: Vale.Def.Words_s.nat64
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_bytes_to_nat64 (Vale.Def.Types_s.le_nat64_to_bytes s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Words_s.nat64",
"Vale.Def.Types_s.le_bytes_to_nat64_reveal",
"Prims.unit",
"Vale.Def.Types_s.le_nat64_to_bytes_reveal"
] | [] | true | false | true | false | false | let le_bytes_to_nat64_to_bytes s =
| le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_quad32_to_bytes_injective | val le_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | val le_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') | let le_quad32_to_bytes_injective ():
Lemma (forall b b' . le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b')
=
reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
let helper (b b':quad32) : Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
if le_quad32_to_bytes b = le_quad32_t... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 475,
"start_col": 0,
"start_line": 455
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (b: Vale.Def.Types_s.quad32) (b': Vale.Def.Types_s.quad32).
Vale.Def.Types_s.le_quad32_to_bytes b == Vale.Def.Types_s.le_quad32_to_bytes b' ==> b == b') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_imp",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Vale.Def.Words_s.nat8",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Pr... | [] | false | false | true | false | false | let le_quad32_to_bytes_injective ()
: Lemma (forall b b'. le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
| reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes;
let helper (b b': quad32) : Lemma (le_quad32_to_bytes b == le_quad32_to_bytes b' ==> b == b') =
if le_quad32_to_bytes b = le_quad32_to_bytes b'
then
(let b1 = seq_map (nat_to_four 8) (four_to_seq_LE b) in
let b1' = seq_map (nat_to_four 8) (four_to_s... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_nat64_to_bytes_to_nat64 | val le_nat64_to_bytes_to_nat64 (s:seq nat8 { length s == 8 }) :
Lemma (le_nat64_to_bytes (le_bytes_to_nat64 s) == s) | val le_nat64_to_bytes_to_nat64 (s:seq nat8 { length s == 8 }) :
Lemma (le_nat64_to_bytes (le_bytes_to_nat64 s) == s) | let le_nat64_to_bytes_to_nat64 n =
le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 307,
"start_col": 0,
"start_line": 305
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 3,
"max_fuel": 3,
"max_ifuel": 3,
"no_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 Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s == 8}
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_nat64_to_bytes (Vale.Def.Types_s.le_bytes_to_nat64 s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Vale.Def.Types_s.le_bytes_to_nat64_reveal",
"Prims.unit",
"Vale.Def.Types_s.le_nat64_to_bytes_reveal"
] | [] | true | false | true | false | false | let le_nat64_to_bytes_to_nat64 n =
| le_nat64_to_bytes_reveal ();
le_bytes_to_nat64_reveal () | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_quad32_to_bytes_injective | val be_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | val be_quad32_to_bytes_injective: unit ->
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') | let be_quad32_to_bytes_injective ():
Lemma (forall b b' . be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b')
=
reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
let helper (b b':quad32) : Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
if be_quad32_to_bytes b = be_quad32_t... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 497,
"start_col": 0,
"start_line": 477
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | _: Prims.unit
-> FStar.Pervasives.Lemma
(ensures
forall (b: Vale.Def.Types_s.quad32) (b': Vale.Def.Types_s.quad32).
Vale.Arch.Types.be_quad32_to_bytes b == Vale.Arch.Types.be_quad32_to_bytes b' ==> b == b') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Prims.unit",
"FStar.Classical.forall_intro_2",
"Vale.Def.Types_s.quad32",
"Prims.l_imp",
"Prims.eq2",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Def.Words_s.nat8",
"Vale.Arch.Types.be_quad32_to_bytes",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_Equality",
... | [] | false | false | true | false | false | let be_quad32_to_bytes_injective ()
: Lemma (forall b b'. be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
| reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes;
let helper (b b': quad32) : Lemma (be_quad32_to_bytes b == be_quad32_to_bytes b' ==> b == b') =
if be_quad32_to_bytes b = be_quad32_to_bytes b'
then
(let b1 = seq_map (nat_to_four 8) (four_to_seq_BE b) in
let b1' = seq_map (nat_to_four 8) (four_to_s... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.seq_to_four_LE_is_seq_to_seq_four_LE | val seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) | val seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) | let seq_to_four_LE_is_seq_to_seq_four_LE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s)
=
reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (create 1 (seq_to_four_LE s)) (seq_to_seq_four_LE s));
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 522,
"start_col": 0,
"start_line": 517
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.create 1 (Vale.Def.Words.Seq_s.seq_to_four_LE s) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_LE s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_to_four_LE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_LE",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.in... | [] | true | false | true | false | false | let seq_to_four_LE_is_seq_to_seq_four_LE (#a: Type) (s: seq4 a)
: Lemma (create 1 (seq_to_four_LE s) == seq_to_seq_four_LE s) =
| reveal_opaque (`%seq_to_seq_four_LE) (seq_to_seq_four_LE #a);
assert (equal (create 1 (seq_to_four_LE s)) (seq_to_seq_four_LE s));
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32_quad32 | val lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))] | val lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))] | let lemma_reverse_reverse_bytes_nat32_quad32 (s:quad32) :
Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))]
=
let s' = reverse_bytes_nat32_quad32 s in
let s''= reverse_bytes_nat32_quad32 s' in
assert (s''.lo0 == revers... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 590,
"start_col": 0,
"start_line": 580
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_nat32_quad32 (Vale.Arch.Types.reverse_bytes_nat32_quad32 s) ==
s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_nat32_quad32 (Vale.Arch.Types.reverse_bytes_nat32_quad32
s))
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Vale.Def.Types_s.nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi3",
"Vale.Def.Types_s.reverse_bytes_nat32",
"Vale.Def.Words_s.__proj__Mkfour__item__hi2",
"Vale.Def.Words_s.__proj__Mkfour__item__lo1",
"Vale.Def.Words_s.__pro... | [] | true | false | true | false | false | let lemma_reverse_reverse_bytes_nat32_quad32 (s: quad32)
: Lemma (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s) == s)
[SMTPat (reverse_bytes_nat32_quad32 (reverse_bytes_nat32_quad32 s))] =
| let s' = reverse_bytes_nat32_quad32 s in
let s'' = reverse_bytes_nat32_quad32 s' in
assert (s''.lo0 == reverse_bytes_nat32 (reverse_bytes_nat32 s.lo0));
assert (s''.lo1 == reverse_bytes_nat32 (reverse_bytes_nat32 s.lo1));
assert (s''.hi2 == reverse_bytes_nat32 (reverse_bytes_nat32 s.hi2));
assert (s''.hi3 == reverse_by... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_quad32_to_bytes | val le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q) | val le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q) | let le_bytes_to_quad32_to_bytes (q:quad32) :
Lemma(le_bytes_to_quad32 (le_quad32_to_bytes q) == q)
=
le_seq_quad32_to_bytes_of_singleton q; // ==> le_quad32_to_bytes q == le_seq_quad32_to_bytes (create 1 q)
let b = le_quad32_to_bytes q in
let q' = le_bytes_to_quad32 b in
le_bytes_to_seq_quad_of_singleton q... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 568,
"start_col": 0,
"start_line": 555
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_bytes_to_quad32 (Vale.Def.Types_s.le_quad32_to_bytes q) == q) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.index",
"FStar.Seq.Base.create",
"Vale.Arch.Types.le_bytes_to_seq_quad32_to_bytes",
"Vale.Arch.Types.le_bytes_to_seq_quad_of_singleton",
"Vale.Def.Types_s.le_bytes_to_quad32",
"FStar.Seq.Base.seq",
"Vale.Def.W... | [] | true | false | true | false | false | let le_bytes_to_quad32_to_bytes (q: quad32) : Lemma (le_bytes_to_quad32 (le_quad32_to_bytes q) == q) =
| le_seq_quad32_to_bytes_of_singleton q;
let b = le_quad32_to_bytes q in
let q' = le_bytes_to_quad32 b in
le_bytes_to_seq_quad_of_singleton q' b;
le_bytes_to_seq_quad32_to_bytes (create 1 q);
assert (q == index (create 1 q) 0);
assert (q == q');
() | false |
SteelFramingTestSuite.fst | SteelFramingTestSuite.test7 | val test7: unit -> SteelT ref emp ptr | val test7: unit -> SteelT ref emp ptr | let test7 (_:unit) : SteelT ref emp ptr
= let r = alloc 0 in
let x = read r in
write r 0;
r | {
"file_name": "share/steel/tests/SteelFramingTestSuite.fst",
"git_rev": "f984200f79bdc452374ae994a5ca837496476c41",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | {
"end_col": 5,
"end_line": 103,
"start_col": 0,
"start_line": 99
} | (*
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.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "SteelFramingTestSuite.fst"
} | [
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | _: Prims.unit -> Steel.Effect.SteelT SteelFramingTestSuite.ref | Steel.Effect.SteelT | [] | [] | [
"Prims.unit",
"SteelFramingTestSuite.ref",
"SteelFramingTestSuite.write",
"Prims.int",
"SteelFramingTestSuite.read",
"SteelFramingTestSuite.alloc",
"Steel.Effect.Common.emp",
"SteelFramingTestSuite.ptr"
] | [] | false | true | false | false | false | let test7 (_: unit) : SteelT ref emp ptr =
| let r = alloc 0 in
let x = read r in
write r 0;
r | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_seq_quad_of_singleton | val le_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == le_bytes_to_quad32 b)
(ensures create 1 q == le_bytes_to_seq_quad32 b) | val le_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == le_bytes_to_quad32 b)
(ensures create 1 q == le_bytes_to_seq_quad32 b) | let le_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == le_bytes_to_quad32 b)
(ensures create 1 q == le_bytes_to_seq_quad32 b)
=
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_bytes_to_quad32_reveal ();
seq_to_four_LE_is_seq_to_seq_four_LE... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 544,
"start_col": 0,
"start_line": 531
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
q: Vale.Def.Types_s.quad32 ->
b: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length b == 16}
-> FStar.Pervasives.Lemma (requires q == Vale.Def.Types_s.le_bytes_to_quad32 b)
(ensures FStar.Seq.Base.create 1 q == Vale.Def.Types_s.le_bytes_to_seq_quad32 b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Arch.Types.seq_to_four_LE_is_seq_to_seq_four_LE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Lib.Seqs_s.seq_map",
"Vale.Def.... | [] | true | false | true | false | false | let le_bytes_to_seq_quad_of_singleton (q: quad32) (b: seq nat8 {length b == 16})
: Lemma (requires q == le_bytes_to_quad32 b) (ensures create 1 q == le_bytes_to_seq_quad32 b) =
| reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
le_bytes_to_quad32_reveal ();
seq_to_four_LE_is_seq_to_seq_four_LE (seq_map (four_to_nat 8) (seq_to_seq_four_LE b));
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_bytes_to_quad32_to_bytes | val be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
[SMTPat (be_bytes_to_quad32 (be_quad32_to_bytes q))] | val be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
[SMTPat (be_bytes_to_quad32 (be_quad32_to_bytes q))] | let be_bytes_to_quad32_to_bytes (q:quad32) :
Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q)
=
be_bytes_to_quad32_reveal ();
let q':quad32 = be_bytes_to_quad32 (be_quad32_to_bytes q) in
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (four_to_seq_BE q));
seq_map_inverses (nat_to_four 8) (four_to_n... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 578,
"start_col": 0,
"start_line": 570
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | q: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.be_bytes_to_quad32 (Vale.Arch.Types.be_quad32_to_bytes q) == q)
[SMTPat (Vale.Def.Types_s.be_bytes_to_quad32 (Vale.Arch.Types.be_quad32_to_bytes q))] | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Prims.unit",
"Vale.Def.Words.Seq.seq_to_four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"Vale.Def.Words.Four_s.nat_to_four",
"Vale.Def.Words.Four_s.four_to_nat",
"Vale.Def.Wor... | [] | true | false | true | false | false | let be_bytes_to_quad32_to_bytes (q: quad32) : Lemma (be_bytes_to_quad32 (be_quad32_to_bytes q) == q) =
| be_bytes_to_quad32_reveal ();
let q':quad32 = be_bytes_to_quad32 (be_quad32_to_bytes q) in
seq_to_seq_four_to_seq_BE (seq_map (nat_to_four 8) (four_to_seq_BE q));
seq_map_inverses (nat_to_four 8) (four_to_nat 8) (four_to_seq_BE q);
seq_to_four_to_seq_BE q;
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_reverse_reverse_bytes_quad32_seq | val lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))] | val lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))] | let lemma_reverse_reverse_bytes_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))]
=
seq_map_inverses reverse_bytes_quad32 reverse_bytes_quad32 s | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 62,
"end_line": 602,
"start_col": 0,
"start_line": 598
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_quad32_seq (Vale.Arch.Types.reverse_bytes_quad32_seq s) == s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_quad32_seq (Vale.Arch.Types.reverse_bytes_quad32_seq s
))
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Arch.Types.reverse_bytes_quad32_seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat... | [] | true | false | true | false | false | let lemma_reverse_reverse_bytes_quad32_seq (s: seq quad32)
: Lemma (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s) == s)
[SMTPat (reverse_bytes_quad32_seq (reverse_bytes_quad32_seq s))] =
| seq_map_inverses reverse_bytes_quad32 reverse_bytes_quad32 s | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_bytes_to_seq_quad_of_singleton | val be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b) | val be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b) | let be_bytes_to_seq_quad_of_singleton (q:quad32) (b:seq nat8 { length b == 16 }) : Lemma
(requires q == be_bytes_to_quad32 b)
(ensures create 1 q == be_bytes_to_seq_quad32 b)
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
be_bytes_to_quad32_reveal ();
seq_to_four_BE_is_seq_to_seq_four_BE... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 553,
"start_col": 0,
"start_line": 546
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
q: Vale.Def.Types_s.quad32 ->
b: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length b == 16}
-> FStar.Pervasives.Lemma (requires q == Vale.Def.Types_s.be_bytes_to_quad32 b)
(ensures FStar.Seq.Base.create 1 q == Vale.Def.Types_s.be_bytes_to_seq_quad32 b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Arch.Types.seq_to_four_BE_is_seq_to_seq_four_BE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Lib.Seqs_s.seq_map",
"Vale.Def.... | [] | true | false | true | false | false | let be_bytes_to_seq_quad_of_singleton (q: quad32) (b: seq nat8 {length b == 16})
: Lemma (requires q == be_bytes_to_quad32 b) (ensures create 1 q == be_bytes_to_seq_quad32 b) =
| reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
be_bytes_to_quad32_reveal ();
seq_to_four_BE_is_seq_to_seq_four_BE (seq_map (four_to_nat 8) (seq_to_seq_four_BE b));
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_reverse_reverse_bytes_nat32_quad32_seq | val lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))] | val lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))] | let lemma_reverse_reverse_bytes_nat32_quad32_seq (s:seq quad32) :
Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))]
=
seq_map_inverses reverse_bytes_nat32_quad32 reverse_bytes_nat32_quad32 s | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 74,
"end_line": 596,
"start_col": 0,
"start_line": 592
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Arch.Types.reverse_bytes_nat32_quad32_seq (Vale.Arch.Types.reverse_bytes_nat32_quad32_seq
s) ==
s)
[
SMTPat (Vale.Arch.Types.reverse_bytes_nat32_quad32_seq (Vale.Arch.Types.reverse_b... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Vale.Lib.Seqs.seq_map_inverses",
"Vale.Arch.Types.reverse_bytes_nat32_quad32",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Arch.Types.reverse_bytes_nat32_quad32_seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasi... | [] | true | false | true | false | false | let lemma_reverse_reverse_bytes_nat32_quad32_seq (s: seq quad32)
: Lemma (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s) == s)
[SMTPat (reverse_bytes_nat32_quad32_seq (reverse_bytes_nat32_quad32_seq s))] =
| seq_map_inverses reverse_bytes_nat32_quad32 reverse_bytes_nat32_quad32 s | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_seq_four_to_seq_BE | val slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n')) | val slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n')) | let slice_commutes_seq_four_to_seq_BE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
seq_four_to_seq_BE (slice s n n'))
=
reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (slice (s... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 630,
"start_col": 0,
"start_line": 623
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_four_to_seq_BE s) (n * 4) (n' * 4) ==
Vale.Def.Words.S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"FStar.Mul.op_Star",
"FStar... | [] | true | false | true | false | false | let slice_commutes_seq_four_to_seq_BE
(#a: Type)
(s: seq (four a))
(n: nat{n <= length s})
(n': nat{n <= n' /\ n' <= length s})
: Lemma (slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) == seq_four_to_seq_BE (slice s n n')) =
| reveal_opaque (`%seq_four_to_seq_BE) (seq_four_to_seq_BE #a);
assert (equal (slice (seq_four_to_seq_BE s) (n * 4) (n' * 4)) (seq_four_to_seq_BE (slice s n n')));
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.seq_to_four_BE_is_seq_to_seq_four_BE | val seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) | val seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) | let seq_to_four_BE_is_seq_to_seq_four_BE (#a:Type) (s:seq4 a) : Lemma
(create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s)
=
reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (create 1 (seq_to_four_BE s)) (seq_to_seq_four_BE s));
() | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 529,
"start_col": 0,
"start_line": 524
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: Vale.Def.Words.Seq_s.seq4 a
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.create 1 (Vale.Def.Words.Seq_s.seq_to_four_BE s) ==
Vale.Def.Words.Seq_s.seq_to_seq_four_BE s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Words.Seq_s.seq4",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"Vale.Def.Words_s.four",
"FStar.Seq.Base.create",
"Vale.Def.Words.Seq_s.seq_to_four_BE",
"Vale.Def.Words.Seq_s.seq_to_seq_four_BE",
"FStar.Pervasives.reveal_opaque",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Prims.in... | [] | true | false | true | false | false | let seq_to_four_BE_is_seq_to_seq_four_BE (#a: Type) (s: seq4 a)
: Lemma (create 1 (seq_to_four_BE s) == seq_to_seq_four_BE s) =
| reveal_opaque (`%seq_to_seq_four_BE) (seq_to_seq_four_BE #a);
assert (equal (create 1 (seq_to_four_BE s)) (seq_to_seq_four_BE s));
() | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes0 | val slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n)) | val slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n)) | let slice_commutes_le_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) 0 (n * 16) ==
le_seq_quad32_to_bytes (slice s 0 n))
=
slice_commutes_le_seq_quad32_to_bytes s 0 n | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 668,
"start_col": 0,
"start_line": 664
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> n: Prims.nat{n <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Types_s.le_seq_quad32_to_bytes s) 0 (n * 16) ==
Vale.Def.Types_s.le_seq_quad32_to_bytes (FStar.Seq.Base.slice s 0 n)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Types_s.nat8",
"FStar.Seq.Base.slice",... | [] | true | false | true | false | false | let slice_commutes_le_seq_quad32_to_bytes0 (s: seq quad32) (n: nat{n <= length s})
: Lemma (slice (le_seq_quad32_to_bytes s) 0 (n * 16) == le_seq_quad32_to_bytes (slice s 0 n)) =
| slice_commutes_le_seq_quad32_to_bytes s 0 n | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint8_hex_pad | val print_uint8_hex_pad: uint8 -> FStar.All.ML unit | val print_uint8_hex_pad: uint8 -> FStar.All.ML unit | let print_uint8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 55,
"start_col": 0,
"start_line": 54
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint8 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint8",
"FStar.IO.print_uint8_hex_pad",
"Lib.RawIntTypes.u8_to_UInt8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint8_hex_pad x =
| IO.print_uint8_hex_pad (u8_to_UInt8 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint8_hex | val print_uint8_hex: uint8 -> FStar.All.ML unit | val print_uint8_hex: uint8 -> FStar.All.ML unit | let print_uint8_hex x =
IO.print_uint8 (u8_to_UInt8 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint8 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint8",
"FStar.IO.print_uint8",
"Lib.RawIntTypes.u8_to_UInt8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint8_hex x =
| IO.print_uint8 (u8_to_UInt8 x) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_bytes_to_seq_quad32_to_bytes_one_quad | val be_bytes_to_seq_quad32_to_bytes_one_quad (b:quad32) :
Lemma (be_bytes_to_seq_quad32 (be_quad32_to_bytes b) == create 1 b) | val be_bytes_to_seq_quad32_to_bytes_one_quad (b:quad32) :
Lemma (be_bytes_to_seq_quad32 (be_quad32_to_bytes b) == create 1 b) | let be_bytes_to_seq_quad32_to_bytes_one_quad b =
calc (==) {
be_bytes_to_seq_quad32 (be_quad32_to_bytes b);
== {reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32}
seq_to_seq_four_BE (seq_nat8_to_seq_nat32_BE (be_quad32_to_bytes b));
== {reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_b... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 359,
"start_col": 0,
"start_line": 342
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | b: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.be_bytes_to_seq_quad32 (Vale.Arch.Types.be_quad32_to_bytes b) ==
FStar.Seq.Base.create 1 b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Calc.calc_finish",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Vale.Def.Types_s.be_bytes_to_seq_quad32",
"Vale.Arch.Types.be_quad32_to_bytes",
"FStar.Seq.Base.create",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.... | [] | false | false | true | false | false | let be_bytes_to_seq_quad32_to_bytes_one_quad b =
| calc ( == ) {
be_bytes_to_seq_quad32 (be_quad32_to_bytes b);
( == ) { reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32 }
seq_to_seq_four_BE (seq_nat8_to_seq_nat32_BE (be_quad32_to_bytes b));
( == ) { reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes }
seq_to_seq_four_BE (seq_nat8_to_seq_n... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes | val slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n'))) | val slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n'))) | let slice_commutes_be_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n')))
=
slice_commutes_seq_four_to_seq_BE s n n... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 662,
"start_col": 0,
"start_line": 652
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Vale.Arch.Types.slice_commutes_seq_four_to_seq_BE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.four... | [] | true | false | true | false | false | let slice_commutes_be_seq_quad32_to_bytes
(s: seq quad32)
(n: nat{n <= length s})
(n': nat{n <= n' /\ n' <= length s})
: Lemma
(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) (n * 16) (n' * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s n n'))) =
| slice_commutes_seq_four_to_seq_BE s n n';
assert (slice (seq_four_to_seq_BE s) (n * 4) (n' * 4) == seq_four_to_seq_BE (slice s n n'));
slice_seq_map_commute (nat_to_four 8) (seq_four_to_seq_BE s) (n * 4) (n' * 4);
let s_inner = (seq_map (nat_to_four 8) (seq_four_to_seq_BE s)) in
slice_commutes_seq_four_to_seq_BE s_inne... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint32_hex | val print_uint32_hex: uint32 -> FStar.All.ML unit | val print_uint32_hex: uint32 -> FStar.All.ML unit | let print_uint32_hex x =
IO.print_uint32 (u32_to_UInt32 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 65,
"start_col": 0,
"start_line": 64
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint32 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint32",
"FStar.IO.print_uint32",
"Lib.RawIntTypes.u32_to_UInt32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint32_hex x =
| IO.print_uint32 (u32_to_UInt32 x) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes0 | val slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n))) | val slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n))) | let slice_commutes_be_seq_quad32_to_bytes0 (s:seq quad32) (n:nat{n <= length s}) :
Lemma(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n)))
=
slice_commutes_be_seq_quad32_to_bytes s 0 n | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 674,
"start_col": 0,
"start_line": 670
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> n: Prims.nat{n <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE
s))
0
(n * 16) ==
Vale.Def.Words.S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Vale.Arch.Types.slice_commutes_be_seq_quad32_to_bytes",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Def.Words_s.nat8",
"FStar.Seq.Base.slice",... | [] | true | false | true | false | false | let slice_commutes_be_seq_quad32_to_bytes0 (s: seq quad32) (n: nat{n <= length s})
: Lemma
(slice (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s)) 0 (n * 16) ==
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (slice s 0 n))) =
| slice_commutes_be_seq_quad32_to_bytes s 0 n | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_le_seq_quad32_to_bytes | val slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n')) | val slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n')) | let slice_commutes_le_seq_quad32_to_bytes (s:seq quad32) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
le_seq_quad32_to_bytes (slice s n n'))
=
le_seq_quad32_to_bytes_reveal ();
slice_commutes_seq_four_to_seq_LE s n n';
asser... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 650,
"start_col": 0,
"start_line": 632
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Types_s.le_seq_quad32_to_bytes s) (n * 16) (n' * 16) ==
Vale.Def.Types_s... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Vale.Arch.Types.slice_commutes_seq_four_to_seq_LE",
"Vale.Def.Words_s.natN",
"Prims.pow2",
"FStar.Mul.op_Star",
"Vale.Def.Words_s.four... | [] | true | false | true | false | false | let slice_commutes_le_seq_quad32_to_bytes
(s: seq quad32)
(n: nat{n <= length s})
(n': nat{n <= n' /\ n' <= length s})
: Lemma
(slice (le_seq_quad32_to_bytes s) (n * 16) (n' * 16) == le_seq_quad32_to_bytes (slice s n n')) =
| le_seq_quad32_to_bytes_reveal ();
slice_commutes_seq_four_to_seq_LE s n n';
assert (slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) == seq_four_to_seq_LE (slice s n n'));
slice_seq_map_commute (nat_to_four 8) (seq_four_to_seq_LE s) (n * 4) (n' * 4);
let s_inner = (seq_map (nat_to_four 8) (seq_four_to_seq_LE s)) in
slice_... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.slice_commutes_seq_four_to_seq_LE | val slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n')) | val slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n')) | let slice_commutes_seq_four_to_seq_LE (#a:Type) (s:seq (four a)) (n:nat{n <= length s}) (n':nat{ n <= n' /\ n' <= length s}) :
Lemma(slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
seq_four_to_seq_LE (slice s n n'))
=
reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (slice (s... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 621,
"start_col": 0,
"start_line": 614
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s: FStar.Seq.Base.seq (Vale.Def.Words_s.four a) ->
n: Prims.nat{n <= FStar.Seq.Base.length s} ->
n': Prims.nat{n <= n' /\ n' <= FStar.Seq.Base.length s}
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.slice (Vale.Def.Words.Seq_s.seq_four_to_seq_LE s) (n * 4) (n' * 4) ==
Vale.Def.Words.S... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.four",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"Prims.l_and",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"Vale.Def.Words.Seq_s.seq_four_to_seq_LE",
"FStar.Mul.op_Star",
"FStar... | [] | true | false | true | false | false | let slice_commutes_seq_four_to_seq_LE
(#a: Type)
(s: seq (four a))
(n: nat{n <= length s})
(n': nat{n <= n' /\ n' <= length s})
: Lemma (slice (seq_four_to_seq_LE s) (n * 4) (n' * 4) == seq_four_to_seq_LE (slice s n n')) =
| reveal_opaque (`%seq_four_to_seq_LE) (seq_four_to_seq_LE #a);
assert (equal (slice (seq_four_to_seq_LE s) (n * 4) (n' * 4)) (seq_four_to_seq_LE (slice s n n')));
() | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint8_dec | val print_uint8_dec: uint8 -> FStar.All.ML unit | val print_uint8_dec: uint8 -> FStar.All.ML unit | let print_uint8_dec x =
IO.print_uint8_dec (u8_to_UInt8 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 36,
"end_line": 58,
"start_col": 0,
"start_line": 57
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint8 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint8",
"FStar.IO.print_uint8_dec",
"Lib.RawIntTypes.u8_to_UInt8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint8_dec x =
| IO.print_uint8_dec (u8_to_UInt8 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint32_hex_pad | val print_uint32_hex_pad: uint32 -> FStar.All.ML unit | val print_uint32_hex_pad: uint32 -> FStar.All.ML unit | let print_uint32_hex_pad x =
IO.print_uint32_hex_pad (u32_to_UInt32 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 68,
"start_col": 0,
"start_line": 67
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint32 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint32",
"FStar.IO.print_uint32_hex_pad",
"Lib.RawIntTypes.u32_to_UInt32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint32_hex_pad x =
| IO.print_uint32_hex_pad (u32_to_UInt32 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint64_hex | val print_uint64_hex: uint64 -> FStar.All.ML unit | val print_uint64_hex: uint64 -> FStar.All.ML unit | let print_uint64_hex x =
IO.print_uint64 (u64_to_UInt64 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 35,
"end_line": 78,
"start_col": 0,
"start_line": 77
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint64 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.IO.print_uint64",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint64_hex x =
| IO.print_uint64 (u64_to_UInt64 x) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.append_distributes_be_bytes_to_seq_quad32 | val append_distributes_be_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(be_bytes_to_seq_quad32 (s1 @| s2) == (be_bytes_to_seq_quad32 s1) @| (be_bytes_to_seq_quad32 s2)) | val append_distributes_be_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(be_bytes_to_seq_quad32 (s1 @| s2) == (be_bytes_to_seq_quad32 s1) @| (be_bytes_to_seq_quad32 s2)) | let append_distributes_be_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(be_bytes_to_seq_quad32 (s1 @| s2) == (be_bytes_to_seq_quad32 s1) @| (be_bytes_to_seq_quad32 s2))
=
reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
let s1' = seq_nat8... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 705,
"start_col": 0,
"start_line": 696
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s1: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s1 % 16 == 0} ->
s2: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s2 % 16 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.be_bytes_to_seq_quad32 (s1 @| s2) ==
Vale.Def.Types_s.be_bytes_to_seq_quad... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Def.Words.Seq.append_distributes_seq_to_seq_four_BE",
"Vale.Lib.Seqs.append_distributes_seq_map",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.p... | [] | true | false | true | false | false | let append_distributes_be_bytes_to_seq_quad32
(s1: seq nat8 {length s1 % 16 == 0})
(s2: seq nat8 {length s2 % 16 == 0})
: Lemma
(be_bytes_to_seq_quad32 (s1 @| s2) == (be_bytes_to_seq_quad32 s1) @| (be_bytes_to_seq_quad32 s2)
) =
| reveal_opaque (`%be_bytes_to_seq_quad32) be_bytes_to_seq_quad32;
let s1' = seq_nat8_to_seq_nat32_BE s1 in
let s2' = seq_nat8_to_seq_nat32_BE s2 in
append_distributes_seq_to_seq_four_BE s1' s2';
append_distributes_seq_map (four_to_nat 8) (seq_to_seq_four_BE s1) (seq_to_seq_four_BE s2);
append_distributes_seq_to_seq_four... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint8_dec_pad | val print_uint8_dec_pad: uint8 -> FStar.All.ML unit | val print_uint8_dec_pad: uint8 -> FStar.All.ML unit | let print_uint8_dec_pad x =
IO.print_uint8_dec_pad (u8_to_UInt8 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 40,
"end_line": 61,
"start_col": 0,
"start_line": 60
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint8 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint8",
"FStar.IO.print_uint8_dec_pad",
"Lib.RawIntTypes.u8_to_UInt8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint8_dec_pad x =
| IO.print_uint8_dec_pad (u8_to_UInt8 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat8_hex_pad | val print_nat8_hex_pad: x:nat{x <= maxint U8} -> FStar.All.ML unit | val print_nat8_hex_pad: x:nat{x <= maxint U8} -> FStar.All.ML unit | let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 16,
"start_col": 0,
"start_line": 15
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U8} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U8",
"FStar.IO.print_uint8_hex_pad",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.IntTypes.u8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat8_hex_pad x =
| IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint32_dec | val print_uint32_dec: uint32 -> FStar.All.ML unit | val print_uint32_dec: uint32 -> FStar.All.ML unit | let print_uint32_dec x =
IO.print_uint32_dec (u32_to_UInt32 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 71,
"start_col": 0,
"start_line": 70
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint32 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint32",
"FStar.IO.print_uint32_dec",
"Lib.RawIntTypes.u32_to_UInt32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint32_dec x =
| IO.print_uint32_dec (u32_to_UInt32 x) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_quad32_to_bytes_to_quad32 | val le_quad32_to_bytes_to_quad32 (s:seq nat8 { length s == 16 }) :
Lemma(le_quad32_to_bytes (le_bytes_to_quad32 s) == s) | val le_quad32_to_bytes_to_quad32 (s:seq nat8 { length s == 16 }) :
Lemma(le_quad32_to_bytes (le_bytes_to_quad32 s) == s) | let le_quad32_to_bytes_to_quad32 s =
calc (==) {
le_quad32_to_bytes (le_bytes_to_quad32 s);
== {le_bytes_to_quad32_reveal ()}
le_quad32_to_bytes (seq_to_four_LE (seq_map (four_to_nat 8) (seq_to_seq_four_LE s)));
== {reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes}
seq_four_to_seq_LE (seq_m... | {
"file_name": "vale/code/arch/Vale.Arch.Types.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": 410
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s == 16}
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.le_quad32_to_bytes (Vale.Def.Types_s.le_bytes_to_quad32 s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Calc.calc_finish",
"Vale.Def.Types_s.nat8",
"Vale.Def.Types_s.le_quad32_to_bytes",
"Vale.Def.Types_s.le_bytes_to_quad32",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit... | [] | false | false | true | false | false | let le_quad32_to_bytes_to_quad32 s =
| calc ( == ) {
le_quad32_to_bytes (le_bytes_to_quad32 s);
( == ) { le_bytes_to_quad32_reveal () }
le_quad32_to_bytes (seq_to_four_LE (seq_map (four_to_nat 8) (seq_to_seq_four_LE s)));
( == ) { reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes }
seq_four_to_seq_LE (seq_map (nat_to_four 8)
(four_to... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint32_dec_pad | val print_uint32_dec_pad: uint32 -> FStar.All.ML unit | val print_uint32_dec_pad: uint32 -> FStar.All.ML unit | let print_uint32_dec_pad x =
IO.print_uint32_dec_pad (u32_to_UInt32 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 74,
"start_col": 0,
"start_line": 73
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint32 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint32",
"FStar.IO.print_uint32_dec_pad",
"Lib.RawIntTypes.u32_to_UInt32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint32_dec_pad x =
| IO.print_uint32_dec_pad (u32_to_UInt32 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint64_dec_pad | val print_uint64_dec_pad: uint64 -> FStar.All.ML unit | val print_uint64_dec_pad: uint64 -> FStar.All.ML unit | let print_uint64_dec_pad x =
IO.print_uint64_dec_pad (u64_to_UInt64 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 87,
"start_col": 0,
"start_line": 86
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint64 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.IO.print_uint64_dec_pad",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint64_dec_pad x =
| IO.print_uint64_dec_pad (u64_to_UInt64 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint64_hex_pad | val print_uint64_hex_pad: uint64 -> FStar.All.ML unit | val print_uint64_hex_pad: uint64 -> FStar.All.ML unit | let print_uint64_hex_pad x =
IO.print_uint64_hex_pad (u64_to_UInt64 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 43,
"end_line": 81,
"start_col": 0,
"start_line": 80
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint64 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.IO.print_uint64_hex_pad",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint64_hex_pad x =
| IO.print_uint64_hex_pad (u64_to_UInt64 x) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_nat64 | val print_label_nat64: display:bool -> string -> x:nat{x <= maxint U64} -> FStar.All.ML unit | val print_label_nat64: display:bool -> string -> x:nat{x <= maxint U64} -> FStar.All.ML unit | let print_label_nat64 flag s x =
if not flag then () else (
IO.print_string s;
IO.print_string ": ";
print_nat64_dec x;
IO.print_string "\n") | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 95,
"start_col": 0,
"start_line": 90
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> s: Prims.string -> x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U64}
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U64",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"Lib.PrintSequence.print_nat64_dec"
] | [] | false | true | false | false | false | let print_label_nat64 flag s x =
| if not flag
then ()
else
(IO.print_string s;
IO.print_string ": ";
print_nat64_dec x;
IO.print_string "\n") | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat8_hex | val print_nat8_hex: x:nat{x <= maxint U8} -> FStar.All.ML unit | val print_nat8_hex: x:nat{x <= maxint U8} -> FStar.All.ML unit | let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 37,
"end_line": 13,
"start_col": 0,
"start_line": 12
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U8} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U8",
"FStar.IO.print_uint8",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.IntTypes.u8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat8_hex x =
| IO.print_uint8 (u8_to_UInt8 (u8 x)) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.le_bytes_to_seq_quad32_to_bytes_one_quad | val le_bytes_to_seq_quad32_to_bytes_one_quad (b:quad32) :
Lemma (le_bytes_to_seq_quad32 (le_quad32_to_bytes b) == create 1 b) | val le_bytes_to_seq_quad32_to_bytes_one_quad (b:quad32) :
Lemma (le_bytes_to_seq_quad32 (le_quad32_to_bytes b) == create 1 b) | let le_bytes_to_seq_quad32_to_bytes_one_quad b =
calc (==) {
le_bytes_to_seq_quad32 (le_quad32_to_bytes b);
== {reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32}
seq_to_seq_four_LE (seq_nat8_to_seq_nat32_LE (le_quad32_to_bytes b));
== {reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_b... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 340,
"start_col": 0,
"start_line": 323
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | b: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_bytes_to_seq_quad32 (Vale.Def.Types_s.le_quad32_to_bytes b) ==
FStar.Seq.Base.create 1 b) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"FStar.Calc.calc_finish",
"FStar.Seq.Base.seq",
"Prims.eq2",
"Vale.Def.Types_s.le_bytes_to_seq_quad32",
"Vale.Def.Types_s.le_quad32_to_bytes",
"FStar.Seq.Base.create",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale... | [] | false | false | true | false | false | let le_bytes_to_seq_quad32_to_bytes_one_quad b =
| calc ( == ) {
le_bytes_to_seq_quad32 (le_quad32_to_bytes b);
( == ) { reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32 }
seq_to_seq_four_LE (seq_nat8_to_seq_nat32_LE (le_quad32_to_bytes b));
( == ) { reveal_opaque (`%le_quad32_to_bytes) le_quad32_to_bytes }
seq_to_seq_four_LE (seq_nat8_to_seq_n... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_string | val print_string: display:bool -> string -> FStar.All.ML unit | val print_string: display:bool -> string -> FStar.All.ML unit | let print_string flag s = if flag then IO.print_string s else () | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 64,
"end_line": 128,
"start_col": 0,
"start_line": 128
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> s: Prims.string -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"FStar.IO.print_string",
"Prims.unit"
] | [] | false | true | false | false | false | let print_string flag s =
| if flag then IO.print_string s | false |
Vale.Arch.Types.fst | Vale.Arch.Types.append_distributes_be_seq_quad32_to_bytes | val append_distributes_be_seq_quad32_to_bytes (s1:seq quad32) (s2:seq quad32) :
Lemma(seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2)) == (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s1)) @| (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s2))) | val append_distributes_be_seq_quad32_to_bytes (s1:seq quad32) (s2:seq quad32) :
Lemma(seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2)) == (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s1)) @| (seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s2))) | let append_distributes_be_seq_quad32_to_bytes s1 s2 =
calc (==) {
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2));
(==) { }
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2));
(==) { append_distributes_seq_four_to_seq_BE s1 s2 }
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s1 @| seq... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 746,
"start_col": 0,
"start_line": 728
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s1: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> s2: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.Def.Words.Seq_s.seq_four_to_seq_BE (s1 @|
s2)) ==
Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE (Vale.De... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"FStar.Calc.calc_finish",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Vale.Def.Words.Seq_s.seq_nat32_to_seq_nat8_BE",
"Vale.Def.Words.Seq_s.seq_four_to_seq_BE",
"Vale.Def.Types_s.nat32",
"FStar.Seq.Base.op_At_Bar",
"Prims.Cons",
"FStar.Preorder.relatio... | [] | false | false | true | false | false | let append_distributes_be_seq_quad32_to_bytes s1 s2 =
| calc ( == ) {
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2));
( == ) { () }
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE (s1 @| s2));
( == ) { append_distributes_seq_four_to_seq_BE s1 s2 }
seq_nat32_to_seq_nat8_BE (seq_four_to_seq_BE s1 @| seq_four_to_seq_BE s2);
( == ) { append_distributes_seq_ma... | false |
Vale.Arch.Types.fst | Vale.Arch.Types.be_quad32_to_bytes_to_quad32 | val be_quad32_to_bytes_to_quad32 (s:seq nat8 { length s == 16 }) :
Lemma(be_quad32_to_bytes (be_bytes_to_quad32 s) == s) | val be_quad32_to_bytes_to_quad32 (s:seq nat8 { length s == 16 }) :
Lemma(be_quad32_to_bytes (be_bytes_to_quad32 s) == s) | let be_quad32_to_bytes_to_quad32 s =
calc (==) {
be_quad32_to_bytes (be_bytes_to_quad32 s);
== {be_bytes_to_quad32_reveal ()}
be_quad32_to_bytes (seq_to_four_BE (seq_map (four_to_nat 8) (seq_to_seq_four_BE s)));
== {reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes}
seq_four_to_seq_BE (seq_m... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 438,
"start_col": 0,
"start_line": 425
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s == 16}
-> FStar.Pervasives.Lemma
(ensures Vale.Arch.Types.be_quad32_to_bytes (Vale.Def.Types_s.be_bytes_to_quad32 s) == s) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Calc.calc_finish",
"Vale.Def.Words.Seq_s.seq16",
"Vale.Arch.Types.be_quad32_to_bytes",
"Vale.Def.Types_s.be_bytes_to_quad32",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.... | [] | false | false | true | false | false | let be_quad32_to_bytes_to_quad32 s =
| calc ( == ) {
be_quad32_to_bytes (be_bytes_to_quad32 s);
( == ) { be_bytes_to_quad32_reveal () }
be_quad32_to_bytes (seq_to_four_BE (seq_map (four_to_nat 8) (seq_to_seq_four_BE s)));
( == ) { reveal_opaque (`%be_quad32_to_bytes) be_quad32_to_bytes }
seq_four_to_seq_BE (seq_map (nat_to_four 8)
(four_to... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_uint8 | val print_label_uint8: display:bool -> string -> uint8 -> FStar.All.ML unit | val print_label_uint8: display:bool -> string -> uint8 -> FStar.All.ML unit | let print_label_uint8 flag s x =
if not flag then () else (
IO.print_string s;
IO.print_string ": ";
print_uint8_hex_pad x;
IO.print_string "\n") | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 102,
"start_col": 0,
"start_line": 97
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> s: Prims.string -> x: Lib.IntTypes.uint8 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.uint8",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"Lib.PrintSequence.print_uint8_hex_pad"
] | [] | false | true | false | false | false | let print_label_uint8 flag s x =
| if not flag
then ()
else
(IO.print_string s;
IO.print_string ": ";
print_uint8_hex_pad x;
IO.print_string "\n") | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_uint32 | val print_label_uint32: display:bool -> string -> uint32 -> FStar.All.ML unit | val print_label_uint32: display:bool -> string -> uint32 -> FStar.All.ML unit | let print_label_uint32 flag s x =
if not flag then () else (
IO.print_string s;
IO.print_string ": ";
print_uint32_hex_pad x;
IO.print_string "\n") | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 109,
"start_col": 0,
"start_line": 104
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> s: Prims.string -> x: Lib.IntTypes.uint32 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.uint32",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"Lib.PrintSequence.print_uint32_hex_pad"
] | [] | false | true | false | false | false | let print_label_uint32 flag s x =
| if not flag
then ()
else
(IO.print_string s;
IO.print_string ": ";
print_uint32_hex_pad x;
IO.print_string "\n") | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_uint64 | val print_label_uint64: display:bool -> string -> uint64 -> FStar.All.ML unit | val print_label_uint64: display:bool -> string -> uint64 -> FStar.All.ML unit | let print_label_uint64 flag s x =
if not flag then () else (
IO.print_string s;
IO.print_string ": ";
print_uint64_hex_pad x;
IO.print_string "\n") | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 23,
"end_line": 116,
"start_col": 0,
"start_line": 111
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> s: Prims.string -> x: Lib.IntTypes.uint64 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.uint64",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"Lib.PrintSequence.print_uint64_hex_pad"
] | [] | false | true | false | false | false | let print_label_uint64 flag s x =
| if not flag
then ()
else
(IO.print_string s;
IO.print_string ": ";
print_uint64_hex_pad x;
IO.print_string "\n") | false |
Vale.Arch.Types.fst | Vale.Arch.Types.append_distributes_le_seq_quad32_to_bytes | val append_distributes_le_seq_quad32_to_bytes (s1:seq quad32) (s2:seq quad32) :
Lemma(le_seq_quad32_to_bytes (s1 @| s2) == (le_seq_quad32_to_bytes s1) @| (le_seq_quad32_to_bytes s2)) | val append_distributes_le_seq_quad32_to_bytes (s1:seq quad32) (s2:seq quad32) :
Lemma(le_seq_quad32_to_bytes (s1 @| s2) == (le_seq_quad32_to_bytes s1) @| (le_seq_quad32_to_bytes s2)) | let append_distributes_le_seq_quad32_to_bytes s1 s2 =
le_seq_quad32_to_bytes_reveal ();
calc (==) {
le_seq_quad32_to_bytes (s1 @| s2);
(==) { }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq_LE (s1 @| s2));
(==) { append_distributes_seq_four_to_seq_LE s1 s2 }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 3,
"end_line": 726,
"start_col": 0,
"start_line": 707
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 | s1: FStar.Seq.Base.seq Vale.Def.Types_s.quad32 -> s2: FStar.Seq.Base.seq Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_seq_quad32_to_bytes (s1 @| s2) ==
Vale.Def.Types_s.le_seq_quad32_to_bytes s1 @| Vale.Def.Types_s.le_seq_quad32_to_bytes s2) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Types_s.quad32",
"FStar.Calc.calc_finish",
"Vale.Def.Types_s.nat8",
"Prims.eq2",
"Vale.Def.Types_s.le_seq_quad32_to_bytes",
"FStar.Seq.Base.op_At_Bar",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Vale.Def.Words_... | [] | false | false | true | false | false | let append_distributes_le_seq_quad32_to_bytes s1 s2 =
| le_seq_quad32_to_bytes_reveal ();
calc ( == ) {
le_seq_quad32_to_bytes (s1 @| s2);
( == ) { () }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq_LE (s1 @| s2));
( == ) { append_distributes_seq_four_to_seq_LE s1 s2 }
seq_nat32_to_seq_nat8_LE (seq_four_to_seq_LE s1 @| seq_four_to_seq_LE s2);
( == ) { append_distrib... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat8_dec_pad | val print_nat8_dec_pad: x:nat{x <= maxint U8} -> FStar.All.ML unit | val print_nat8_dec_pad: x:nat{x <= maxint U8} -> FStar.All.ML unit | let print_nat8_dec_pad x =
IO.print_uint8_dec_pad (u8_to_UInt8 (u8 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 22,
"start_col": 0,
"start_line": 21
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U8} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U8",
"FStar.IO.print_uint8_dec_pad",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.IntTypes.u8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat8_dec_pad x =
| IO.print_uint8_dec_pad (u8_to_UInt8 (u8 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat8_dec | val print_nat8_dec: x:nat{x <= maxint U8} -> FStar.All.ML unit | val print_nat8_dec: x:nat{x <= maxint U8} -> FStar.All.ML unit | let print_nat8_dec x =
IO.print_uint8_dec (u8_to_UInt8 (u8 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 19,
"start_col": 0,
"start_line": 18
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U8} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U8",
"FStar.IO.print_uint8_dec",
"Lib.RawIntTypes.u8_to_UInt8",
"Lib.IntTypes.u8",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat8_dec x =
| IO.print_uint8_dec (u8_to_UInt8 (u8 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_uint64_dec | val print_uint64_dec: uint64 -> FStar.All.ML unit | val print_uint64_dec: uint64 -> FStar.All.ML unit | let print_uint64_dec x =
IO.print_uint64_dec (u64_to_UInt64 x) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 39,
"end_line": 84,
"start_col": 0,
"start_line": 83
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Lib.IntTypes.uint64 -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Lib.IntTypes.uint64",
"FStar.IO.print_uint64_dec",
"Lib.RawIntTypes.u64_to_UInt64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_uint64_dec x =
| IO.print_uint64_dec (u64_to_UInt64 x) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.append_distributes_le_bytes_to_seq_quad32 | val append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2)) | val append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2)) | let append_distributes_le_bytes_to_seq_quad32 (s1:seq nat8 { length s1 % 16 == 0 }) (s2:seq nat8 { length s2 % 16 == 0 }) :
Lemma(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2))
=
reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
let s1' = seq_nat8... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 694,
"start_col": 0,
"start_line": 677
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"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 |
s1: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s1 % 16 == 0} ->
s2: FStar.Seq.Base.seq Vale.Def.Words_s.nat8 {FStar.Seq.Base.length s2 % 16 == 0}
-> FStar.Pervasives.Lemma
(ensures
Vale.Def.Types_s.le_bytes_to_seq_quad32 (s1 @| s2) ==
Vale.Def.Types_s.le_bytes_to_seq_quad... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"FStar.Seq.Base.seq",
"Vale.Def.Words_s.nat8",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Seq.Base.length",
"Prims.unit",
"Vale.Def.Words.Seq.append_distributes_seq_to_seq_four_LE",
"Vale.Lib.Seqs.append_distributes_seq_map",
"Vale.Def.Words_s.four",
"Vale.Def.Words_s.natN",
"Prims.p... | [] | true | false | true | false | false | let append_distributes_le_bytes_to_seq_quad32
(s1: seq nat8 {length s1 % 16 == 0})
(s2: seq nat8 {length s2 % 16 == 0})
: Lemma
(le_bytes_to_seq_quad32 (s1 @| s2) == (le_bytes_to_seq_quad32 s1) @| (le_bytes_to_seq_quad32 s2)
) =
| reveal_opaque (`%le_bytes_to_seq_quad32) le_bytes_to_seq_quad32;
let s1' = seq_nat8_to_seq_nat32_LE s1 in
let s2' = seq_nat8_to_seq_nat32_LE s2 in
append_distributes_seq_to_seq_four_LE s1' s2';
append_distributes_seq_map (four_to_nat 8) (seq_to_seq_four_LE s1) (seq_to_seq_four_LE s2);
append_distributes_seq_to_seq_four... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat32_hex_pad | val print_nat32_hex_pad: x:nat{x <= maxint U32} -> FStar.All.ML unit | val print_nat32_hex_pad: x:nat{x <= maxint U32} -> FStar.All.ML unit | let print_nat32_hex_pad x =
IO.print_uint32_hex_pad (u32_to_UInt32 (u32 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 29,
"start_col": 0,
"start_line": 28
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U32} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U32",
"FStar.IO.print_uint32_hex_pad",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.u32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat32_hex_pad x =
| IO.print_uint32_hex_pad (u32_to_UInt32 (u32 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_lbytes | val print_label_lbytes: display:bool -> string -> len:size_nat -> lbytes len -> FStar.All.ML unit | val print_label_lbytes: display:bool -> string -> len:size_nat -> lbytes len -> FStar.All.ML unit | let print_label_lbytes flag label len b =
if not flag then () else (
IO.print_string label;
IO.print_string ": \n";
print_lbytes flag len b;
IO.print_newline ()) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 22,
"end_line": 151,
"start_col": 0,
"start_line": 146
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
label: Prims.string ->
len: Lib.IntTypes.size_nat ->
b: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_newline",
"Lib.PrintSequence.print_lbytes",
"FStar.IO.print_string"
] | [] | false | true | false | false | false | let print_label_lbytes flag label len b =
| if not flag
then ()
else
(IO.print_string label;
IO.print_string ": \n";
print_lbytes flag len b;
IO.print_newline ()) | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx512_xcr0 | val avx512_xcr0:bool | val avx512_xcr0:bool | let avx512_xcr0 : bool =
avx_xcr0_enabled && opmask_xcr0_enabled && zmm_hi256_xcr0_enabled && hi16_zmm_xcr0_enabled | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 92,
"end_line": 76,
"start_col": 0,
"start_line": 75
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.avx_xcr0_enabled",
"Vale.X64.CPU_Features_s.opmask_xcr0_enabled",
"Vale.X64.CPU_Features_s.zmm_hi256_xcr0_enabled",
"Vale.X64.CPU_Features_s.hi16_zmm_xcr0_enabled"
] | [] | false | false | false | true | false | let avx512_xcr0:bool =
| avx_xcr0_enabled && opmask_xcr0_enabled && zmm_hi256_xcr0_enabled && hi16_zmm_xcr0_enabled | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.sse_enabled | val sse_enabled:bool | val sse_enabled:bool | let sse_enabled : bool = sse2_enabled && ssse3_enabled && sse4_1_enabled | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 72,
"end_line": 28,
"start_col": 0,
"start_line": 28
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.sse2_enabled",
"Vale.X64.CPU_Features_s.ssse3_enabled",
"Vale.X64.CPU_Features_s.sse4_1_enabled"
] | [] | false | false | false | true | false | let sse_enabled:bool =
| sse2_enabled && ssse3_enabled && sse4_1_enabled | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx512_cpuid_enabled | val avx512_cpuid_enabled:bool | val avx512_cpuid_enabled:bool | let avx512_cpuid_enabled : bool =
avx512f_enabled && avx512dq_enabled && avx512bw_enabled && avx512vl_enabled | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 77,
"end_line": 31,
"start_col": 0,
"start_line": 30
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.avx512f_enabled",
"Vale.X64.CPU_Features_s.avx512dq_enabled",
"Vale.X64.CPU_Features_s.avx512bw_enabled",
"Vale.X64.CPU_Features_s.avx512vl_enabled"
] | [] | false | false | false | true | false | let avx512_cpuid_enabled:bool =
| avx512f_enabled && avx512dq_enabled && avx512bw_enabled && avx512vl_enabled | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat32_dec | val print_nat32_dec: x:nat{x <= maxint U32} -> FStar.All.ML unit | val print_nat32_dec: x:nat{x <= maxint U32} -> FStar.All.ML unit | let print_nat32_dec x =
IO.print_uint32_dec (u32_to_UInt32 (u32 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 32,
"start_col": 0,
"start_line": 31
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U32} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U32",
"FStar.IO.print_uint32_dec",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.u32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat32_dec x =
| IO.print_uint32_dec (u32_to_UInt32 (u32 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat64_dec | val print_nat64_dec: x:nat{x <= maxint U64} -> FStar.All.ML unit | val print_nat64_dec: x:nat{x <= maxint U64} -> FStar.All.ML unit | let print_nat64_dec x =
IO.print_uint64_dec (u64_to_UInt64 (u64 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 45,
"end_line": 45,
"start_col": 0,
"start_line": 44
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U64} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U64",
"FStar.IO.print_uint64_dec",
"Lib.RawIntTypes.u64_to_UInt64",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat64_dec x =
| IO.print_uint64_dec (u64_to_UInt64 (u64 x)) | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx512_enabled | val avx512_enabled:bool | val avx512_enabled:bool | let avx512_enabled : bool = avx512_cpuid_enabled && avx512_xcr0 | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 63,
"end_line": 83,
"start_col": 0,
"start_line": 83
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.avx512_cpuid_enabled",
"Vale.X64.CPU_Features_s.avx512_xcr0"
] | [] | false | false | false | true | false | let avx512_enabled:bool =
| avx512_cpuid_enabled && avx512_xcr0 | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx2_enabled | val avx2_enabled:bool | val avx2_enabled:bool | let avx2_enabled : bool = avx2_cpuid_enabled && avx_xcr0 | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 56,
"end_line": 82,
"start_col": 0,
"start_line": 82
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.avx2_cpuid_enabled",
"Vale.X64.CPU_Features_s.avx_xcr0"
] | [] | false | false | false | true | false | let avx2_enabled:bool =
| avx2_cpuid_enabled && avx_xcr0 | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat32_hex | val print_nat32_hex: x:nat{x <= maxint U32} -> FStar.All.ML unit | val print_nat32_hex: x:nat{x <= maxint U32} -> FStar.All.ML unit | let print_nat32_hex x =
IO.print_uint32 (u32_to_UInt32 (u32 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 26,
"start_col": 0,
"start_line": 25
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U32} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U32",
"FStar.IO.print_uint32",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.u32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat32_hex x =
| IO.print_uint32 (u32_to_UInt32 (u32 x)) | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx_xcr0 | val avx_xcr0:bool | val avx_xcr0:bool | let avx_xcr0 : bool = sse_xcr0_enabled && avx_xcr0_enabled | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 58,
"end_line": 73,
"start_col": 0,
"start_line": 73
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.sse_xcr0_enabled",
"Vale.X64.CPU_Features_s.avx_xcr0_enabled"
] | [] | false | false | false | true | false | let avx_xcr0:bool =
| sse_xcr0_enabled && avx_xcr0_enabled | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat32_dec_pad | val print_nat32_dec_pad: x:nat{x <= maxint U32} -> FStar.All.ML unit | val print_nat32_dec_pad: x:nat{x <= maxint U32} -> FStar.All.ML unit | let print_nat32_dec_pad x =
IO.print_uint32_dec_pad (u32_to_UInt32 (u32 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 35,
"start_col": 0,
"start_line": 34
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U32} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U32",
"FStar.IO.print_uint32_dec_pad",
"Lib.RawIntTypes.u32_to_UInt32",
"Lib.IntTypes.u32",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat32_dec_pad x =
| IO.print_uint32_dec_pad (u32_to_UInt32 (u32 x)) | false |
Vale.X64.CPU_Features_s.fst | Vale.X64.CPU_Features_s.avx_enabled | val avx_enabled:bool | val avx_enabled:bool | let avx_enabled : bool = avx_cpuid_enabled && avx_xcr0 | {
"file_name": "vale/specs/hardware/Vale.X64.CPU_Features_s.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 54,
"end_line": 81,
"start_col": 0,
"start_line": 81
} | module Vale.X64.CPU_Features_s
open FStar.Mul
open Vale.X64.Machine_s
open Vale.Def.Words_s
(* CPUID *)
assume val aesni_enabled : bool // CPUID.01H:ECX.AESNI[bit 25]
assume val avx_cpuid_enabled : bool // CPUID.01H:ECX.AVX[bit 28]
assume val pclmulqdq_enabled : bool // CPUID.01H:ECX.PCLMULQDQ[bit 1]
as... | {
"checked_file": "/",
"dependencies": [
"Vale.X64.Machine_s.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.CPU_Features_s.... | [
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | Prims.bool | Prims.Tot | [
"total"
] | [] | [
"Prims.op_AmpAmp",
"Vale.X64.CPU_Features_s.avx_cpuid_enabled",
"Vale.X64.CPU_Features_s.avx_xcr0"
] | [] | false | false | false | true | false | let avx_enabled:bool =
| avx_cpuid_enabled && avx_xcr0 | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat64_hex | val print_nat64_hex: x:nat{x <= maxint U64} -> FStar.All.ML unit | val print_nat64_hex: x:nat{x <= maxint U64} -> FStar.All.ML unit | let print_nat64_hex x =
IO.print_uint64 (u64_to_UInt64 (u64 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 41,
"end_line": 39,
"start_col": 0,
"start_line": 38
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U64} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U64",
"FStar.IO.print_uint64",
"Lib.RawIntTypes.u64_to_UInt64",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat64_hex x =
| IO.print_uint64 (u64_to_UInt64 (u64 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat64_hex_pad | val print_nat64_hex_pad: x:nat{x <= maxint U64} -> FStar.All.ML unit | val print_nat64_hex_pad: x:nat{x <= maxint U64} -> FStar.All.ML unit | let print_nat64_hex_pad x =
IO.print_uint64_hex_pad (u64_to_UInt64 (u64 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 42,
"start_col": 0,
"start_line": 41
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U64} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U64",
"FStar.IO.print_uint64_hex_pad",
"Lib.RawIntTypes.u64_to_UInt64",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat64_hex_pad x =
| IO.print_uint64_hex_pad (u64_to_UInt64 (u64 x)) | false |
Vale.Arch.Types.fst | Vale.Arch.Types.lemma_reverse_bytes_quad32_64 | val lemma_reverse_bytes_quad32_64 (src orig final:quad32) : Lemma
(requires final == insert_nat64 (insert_nat64 orig (reverse_bytes_nat64 (hi64 src)) 0) (reverse_bytes_nat64 (lo64 src)) 1)
(ensures final == reverse_bytes_quad32 src) | val lemma_reverse_bytes_quad32_64 (src orig final:quad32) : Lemma
(requires final == insert_nat64 (insert_nat64 orig (reverse_bytes_nat64 (hi64 src)) 0) (reverse_bytes_nat64 (lo64 src)) 1)
(ensures final == reverse_bytes_quad32 src) | let lemma_reverse_bytes_quad32_64 (src orig final:quad32) : Lemma
(requires final == insert_nat64 (insert_nat64 orig (reverse_bytes_nat64 (hi64 src)) 0) (reverse_bytes_nat64 (lo64 src)) 1)
(ensures final == reverse_bytes_quad32 src)
=
reverse_bytes_nat64_reveal ();
let Mkfour x0 x1 x2 x3 = src in
let two... | {
"file_name": "vale/code/arch/Vale.Arch.Types.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 244,
"start_col": 0,
"start_line": 200
} | module Vale.Arch.Types
open FStar.Mul
open Vale.Def.Opaque_s
open Vale.Def.Types_s
open Vale.Arch.TypesNative
open Vale.Lib.Seqs
open Vale.Def.Words_s
open Vale.Def.Words.Two
open FStar.Calc
let lemma_nat_to_two32 () =
assert_norm (forall (x:nat64).{:pattern (nat_to_two 32 x)}
nat_to_two 32 x == Mktwo (x % 0x10... | {
"checked_file": "/",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Two.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Def.Opaque_s.fsti.checked",
"Vale.Arch.TypesNative.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fs... | [
{
"abbrev": false,
"full_module": "FStar.Calc",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Two",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.TypesNative",
"short_module": null
},
{
"abbrev": false,
"full_... | {
"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 | src: Vale.Def.Types_s.quad32 -> orig: Vale.Def.Types_s.quad32 -> final: Vale.Def.Types_s.quad32
-> FStar.Pervasives.Lemma
(requires
final ==
Vale.Def.Types_s.insert_nat64 (Vale.Def.Types_s.insert_nat64 orig
(Vale.Def.Types_s.reverse_bytes_nat64 (Vale.Arch.Types.hi64 src))
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Vale.Def.Types_s.quad32",
"Vale.Def.Types_s.nat32",
"Prims.unit",
"FStar.Calc.calc_finish",
"Vale.Def.Types_s.nat64",
"Prims.eq2",
"Vale.Def.Types_s.reverse_bytes_nat64",
"Vale.Arch.Types.lo64",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Vale.Def.Words.Tw... | [] | false | false | true | false | false | let lemma_reverse_bytes_quad32_64 (src orig final: quad32)
: Lemma
(requires
final ==
insert_nat64 (insert_nat64 orig (reverse_bytes_nat64 (hi64 src)) 0)
(reverse_bytes_nat64 (lo64 src))
1) (ensures final == reverse_bytes_quad32 src) =
| reverse_bytes_nat64_reveal ();
let Mkfour x0 x1 x2 x3 = src in
let two32 = (two_to_nat32 (Mktwo (reverse_bytes_nat32 x3) (reverse_bytes_nat32 x2))) in
let two10 = (two_to_nat32 (Mktwo (reverse_bytes_nat32 x1) (reverse_bytes_nat32 x0))) in
calc ( == ) {
reverse_bytes_quad32 src;
( == ) { reveal_reverse_bytes_quad32 ... | false |
Benton2004.RHL.Derived.fst | Benton2004.RHL.Derived.related | val related : c: Benton2004.computation ->
c': Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> Type0 | let related c c' phi phi' = exec_equiv phi phi' c c' | {
"file_name": "examples/rel/Benton2004.RHL.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 52,
"end_line": 88,
"start_col": 0,
"start_line": 88
} | (*
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.Pervasives.fsti.checked",
"Benton2004.RHL.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.RHL.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"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 |
c: Benton2004.computation ->
c': Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.RHL.exec_equiv"
] | [] | false | false | false | true | true | let related c c' phi phi' =
| exec_equiv phi phi' c c' | false | |
Lib.PrintSequence.fst | Lib.PrintSequence.print_compare_display_diff | val print_compare_display_diff: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | val print_compare_display_diff: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | let print_compare_display_diff flag len expected result =
let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag then r
else (
let diff = map2 (fun a b -> a ^. b) expected result in
if r then IO.print_string "\nSuccess !"
else begin
IO.print_string "\n... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 195,
"start_col": 0,
"start_line": 176
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
len: Lib.IntTypes.size_nat ->
expected: Lib.ByteSequence.lbytes len ->
result: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"FStar.IO.print_newline",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint_t",
"Lib.IntTyp... | [] | false | true | false | false | false | let print_compare_display_diff flag len expected result =
| let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag
then r
else
(let diff = map2 (fun a b -> a ^. b) expected result in
if r
then IO.print_string "\nSuccess !"
else
(IO.print_string "\nFailure !";
IO.print_newline ();
IO.print_string "\n... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_nat64_dec_pad | val print_nat64_dec_pad: x:nat{x <= maxint U64} -> FStar.All.ML unit | val print_nat64_dec_pad: x:nat{x <= maxint U64} -> FStar.All.ML unit | let print_nat64_dec_pad x =
IO.print_uint64_dec_pad (u64_to_UInt64 (u64 x)) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 49,
"end_line": 48,
"start_col": 0,
"start_line": 47
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | x: Prims.nat{x <= Lib.IntTypes.maxint Lib.IntTypes.U64} -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.maxint",
"Lib.IntTypes.U64",
"FStar.IO.print_uint64_dec_pad",
"Lib.RawIntTypes.u64_to_UInt64",
"Lib.IntTypes.u64",
"Prims.unit"
] | [] | false | true | false | false | false | let print_nat64_dec_pad x =
| IO.print_uint64_dec_pad (u64_to_UInt64 (u64 x)) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_compare_display | val print_compare_display: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | val print_compare_display: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | let print_compare_display flag len expected result =
let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag then r
else (
if r then IO.print_string "\nSuccess !"
else begin
IO.print_string "\nResult: ";
List.iter (fun a -> print_uint8_hex_pad a) (t... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 174,
"start_col": 0,
"start_line": 162
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
len: Lib.IntTypes.size_nat ->
expected: Lib.ByteSequence.lbytes len ->
result: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC"... | [] | false | true | false | false | false | let print_compare_display flag len expected result =
| let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag
then r
else
(if r
then IO.print_string "\nSuccess !"
else
(IO.print_string "\nResult: ";
List.iter (fun a -> print_uint8_hex_pad a) (to_list result);
IO.print_string "\nExpected: ";
... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_compare | val print_compare: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | val print_compare: display:bool -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | let print_compare flag len expected result =
let r:bool = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if (not flag) then r else (
IO.print_string "\nResult: ";
List.iter (fun a -> print_uint8_hex_pad a) (to_list result);
IO.print_string "\nExpected: ";
List.iter (fun a -... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 160,
"start_col": 0,
"start_line": 153
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
len: Lib.IntTypes.size_nat ->
expected: Lib.ByteSequence.lbytes len ->
result: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.IO.print_string"... | [] | false | true | false | false | false | let print_compare flag len expected result =
| let r:bool = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if (not flag)
then r
else
(IO.print_string "\nResult: ";
List.iter (fun a -> print_uint8_hex_pad a) (to_list result);
IO.print_string "\nExpected: ";
List.iter (fun a -> print_uint8_hex_pad a) (to_list expected);... | false |
Benton2004.RHL.Derived.fst | Benton2004.RHL.Derived.r_ass_derived | val r_ass_derived (x y: var) (e e': exp int) (p p': gexp bool)
: Lemma
(requires
(included p (gsubst (gsubst p' x Left (exp_to_gexp e Left)) y Right (exp_to_gexp e' Right)))
)
(ensures (exec_equiv p p' (assign x e) (assign y e')))
[SMTPat (exec_equiv p p' (assign x e) (assign y e'))] | val r_ass_derived (x y: var) (e e': exp int) (p p': gexp bool)
: Lemma
(requires
(included p (gsubst (gsubst p' x Left (exp_to_gexp e Left)) y Right (exp_to_gexp e' Right)))
)
(ensures (exec_equiv p p' (assign x e) (assign y e')))
[SMTPat (exec_equiv p p' (assign x e) (assign y e'))] | let r_ass_derived
(x y: var)
(e e' : exp int)
(p p': gexp bool)
: Lemma
(requires (
included
p
(gsubst (gsubst p' x Left (exp_to_gexp e Left)) y Right (exp_to_gexp e' Right))
))
(ensures (exec_equiv
p
p'
(assign x e)
(assign y e')
))
[SMTPat (exec_equiv p p' (assign x e) ... | {
"file_name": "examples/rel/Benton2004.RHL.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 34,
"end_line": 38,
"start_col": 0,
"start_line": 21
} | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agre... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"Benton2004.RHL.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.RHL.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Benton2004.var ->
y: Benton2004.var ->
e: Benton2004.exp Prims.int ->
e': Benton2004.exp Prims.int ->
p: Benton2004.RHL.gexp Prims.bool ->
p': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.included p
(Benton2004.RHL.gsubst (Benton... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.exp",
"Prims.int",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.RHL.r_ass",
"Prims.unit",
"Benton2004.RHL.included",
"Benton2004.RHL.gsubst",
"Benton2004.RHL.Left",
"Benton2004.RHL.exp_to_gexp",
"Benton2004.RHL.Right",
"Prims.squash",
"Benton2004.RHL.exec_... | [] | true | false | true | false | false | let r_ass_derived (x y: var) (e e': exp int) (p p': gexp bool)
: Lemma
(requires
(included p (gsubst (gsubst p' x Left (exp_to_gexp e Left)) y Right (exp_to_gexp e' Right)))
)
(ensures (exec_equiv p p' (assign x e) (assign y e')))
[SMTPat (exec_equiv p p' (assign x e) (assign y e'))]... | Benton2004.RHL.r_ass x y e e' p' | false |
Benton2004.RHL.Derived.fst | Benton2004.RHL.Derived.r_dassl_derived | val r_dassl_derived (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Left (exp_to_gexp e Left))))
(ensures (exec_equiv phi phi' (assign x e) skip))
[SMTPat (exec_equiv phi phi' (assign x e) skip)] | val r_dassl_derived (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Left (exp_to_gexp e Left))))
(ensures (exec_equiv phi phi' (assign x e) skip))
[SMTPat (exec_equiv phi phi' (assign x e) skip)] | let r_dassl_derived
(x: var)
(e: exp int)
(phi phi': gexp bool)
: Lemma
(requires (
included phi (gsubst phi' x Left (exp_to_gexp e Left))
))
(ensures (exec_equiv phi phi' (assign x e) skip))
[SMTPat (exec_equiv phi phi' (assign x e) skip)]
= Benton2004.RHL.r_dassl x e phi' | {
"file_name": "examples/rel/Benton2004.RHL.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 33,
"end_line": 50,
"start_col": 0,
"start_line": 40
} | (*
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.Pervasives.fsti.checked",
"Benton2004.RHL.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.RHL.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Benton2004.var ->
e: Benton2004.exp Prims.int ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.included phi
(Benton2004.RHL.gsubst phi'
x
Benton2004.RHL.Left
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.exp",
"Prims.int",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.RHL.r_dassl",
"Prims.unit",
"Benton2004.RHL.included",
"Benton2004.RHL.gsubst",
"Benton2004.RHL.Left",
"Benton2004.RHL.exp_to_gexp",
"Prims.squash",
"Benton2004.RHL.exec_equiv",
"Benton2004.as... | [] | true | false | true | false | false | let r_dassl_derived (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Left (exp_to_gexp e Left))))
(ensures (exec_equiv phi phi' (assign x e) skip))
[SMTPat (exec_equiv phi phi' (assign x e) skip)] =
| Benton2004.RHL.r_dassl x e phi' | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_list_nat64 | val print_list_nat64: display:bool -> list size_nat -> FStar.All.ML unit | val print_list_nat64: display:bool -> list size_nat -> FStar.All.ML unit | let print_list_nat64 flag l =
if not flag then ()
else (
repeat_range_all_ml 0 (List.Tot.length l) (fun i _ ->
print_nat64_dec (List.Tot.index l i);
IO.print_string " "
) ()) | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 7,
"end_line": 125,
"start_col": 0,
"start_line": 119
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> l: Prims.list Lib.IntTypes.size_nat -> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.list",
"Lib.IntTypes.size_nat",
"Prims.op_Negation",
"Prims.unit",
"Lib.LoopCombinators.repeat_range_all_ml",
"FStar.List.Tot.Base.length",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"FStar.IO.print_string",
"Lib.PrintS... | [] | false | true | false | false | false | let print_list_nat64 flag l =
| if not flag
then ()
else
(repeat_range_all_ml 0
(List.Tot.length l)
(fun i _ ->
print_nat64_dec (List.Tot.index l i);
IO.print_string " ")
()) | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_lbytes | val print_lbytes: display:bool -> len:size_nat -> lbytes len -> FStar.All.ML unit | val print_lbytes: display:bool -> len:size_nat -> lbytes len -> FStar.All.ML unit | let print_lbytes flag len b =
if not flag then () else (
let q = 32 in
let n = len / q in
let r = len % q in
if n = 0 then (
List.iter (fun a -> print_uint8_hex_pad a) (to_list b))
else (
repeat_range_all_ml 0 n (fun i _ ->
let sb = sub #uint8 #len b (i * q) q in
List.iter (fun a -> print_uint... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 59,
"end_line": 144,
"start_col": 0,
"start_line": 130
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false | display: Prims.bool -> len: Lib.IntTypes.size_nat -> b: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.unit | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"Prims.op_Equality",
"Prims.int",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.In... | [] | false | true | false | false | false | let print_lbytes flag len b =
| if not flag
then ()
else
(let q = 32 in
let n = len / q in
let r = len % q in
if n = 0
then (List.iter (fun a -> print_uint8_hex_pad a) (to_list b))
else
(repeat_range_all_ml 0
n
(fun i _ ->
let sb = sub #uint8 #len b (i * q) q in
List.iter (fu... | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_compare_display_diff | val print_label_compare_display_diff: display:bool -> s:string -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | val print_label_compare_display_diff: display:bool -> s:string -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | let print_label_compare_display_diff flag s len expected result =
let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag then r
else (
let diff = map2 (fun a b -> a ^. b) expected result in
if r then (
IO.print_string "\nSuccess ! ";
IO.print_string ... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 238,
"start_col": 0,
"start_line": 215
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
s: Prims.string ->
len: Lib.IntTypes.size_nat ->
expected: Lib.ByteSequence.lbytes len ->
result: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_newline",
"FStar.IO.print_string",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint... | [] | false | true | false | false | false | let print_label_compare_display_diff flag s len expected result =
| let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag
then r
else
(let diff = map2 (fun a b -> a ^. b) expected result in
if r
then
(IO.print_string "\nSuccess ! ";
IO.print_string s;
IO.print_newline ())
else
(IO.print_string "\nFai... | false |
Benton2004.RHL.Derived.fst | Benton2004.RHL.Derived.r_dassr | val r_dassr (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Right (exp_to_gexp e Right))))
(ensures (exec_equiv phi phi' skip (assign x e)))
[SMTPat (exec_equiv phi phi' skip (assign x e))] | val r_dassr (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Right (exp_to_gexp e Right))))
(ensures (exec_equiv phi phi' skip (assign x e)))
[SMTPat (exec_equiv phi phi' skip (assign x e))] | let r_dassr
(x: var)
(e: exp int)
(phi phi' : gexp bool)
: Lemma
(requires (
included phi (gsubst phi' x Right (exp_to_gexp e Right))
))
(ensures (exec_equiv phi phi' skip (assign x e)))
[SMTPat (exec_equiv phi phi' skip (assign x e))]
= r_dassl_derived x e (flip phi) (flip phi') | {
"file_name": "examples/rel/Benton2004.RHL.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 44,
"end_line": 69,
"start_col": 0,
"start_line": 59
} | (*
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.Pervasives.fsti.checked",
"Benton2004.RHL.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.RHL.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module"... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
x: Benton2004.var ->
e: Benton2004.exp Prims.int ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.included phi
(Benton2004.RHL.gsubst phi'
x
Benton2004.RHL.Right
... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.var",
"Benton2004.exp",
"Prims.int",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.RHL.Derived.r_dassl_derived",
"Benton2004.RHL.flip",
"Prims.unit",
"Benton2004.RHL.included",
"Benton2004.RHL.gsubst",
"Benton2004.RHL.Right",
"Benton2004.RHL.exp_to_gexp",
"Prims.squash",
"Be... | [] | true | false | true | false | false | let r_dassr (x: var) (e: exp int) (phi phi': gexp bool)
: Lemma (requires (included phi (gsubst phi' x Right (exp_to_gexp e Right))))
(ensures (exec_equiv phi phi' skip (assign x e)))
[SMTPat (exec_equiv phi phi' skip (assign x e))] =
| r_dassl_derived x e (flip phi) (flip phi') | false |
Benton2004.RHL.Derived.fst | Benton2004.RHL.Derived.d_su1'_flip | val d_su1'_flip (c'' c c': computation) (phi phi' phi'': gexp bool)
: Lemma (requires (exec_equiv phi phi' skip c /\ exec_equiv phi' phi'' c'' c'))
(ensures (exec_equiv phi phi'' c'' (seq c c')))
[
SMTPatOr
[
[SMTPat (exec_equiv phi phi'' c'' (seq c c')); SMTPat (exec_equiv phi... | val d_su1'_flip (c'' c c': computation) (phi phi' phi'': gexp bool)
: Lemma (requires (exec_equiv phi phi' skip c /\ exec_equiv phi' phi'' c'' c'))
(ensures (exec_equiv phi phi'' c'' (seq c c')))
[
SMTPatOr
[
[SMTPat (exec_equiv phi phi'' c'' (seq c c')); SMTPat (exec_equiv phi... | let d_su1'_flip
(c'' c c' : computation)
(phi phi' phi'' : gexp bool)
: Lemma
(requires (
exec_equiv phi phi' skip c /\
exec_equiv phi' phi'' c'' c'
))
(ensures (exec_equiv phi phi'' c'' (seq c c')))
[SMTPatOr [
[SMTPat (exec_equiv phi phi'' c'' (seq c c')); SMTPat (exec_equiv phi phi' skip c)]... | {
"file_name": "examples/rel/Benton2004.RHL.Derived.fst",
"git_rev": "10183ea187da8e8c426b799df6c825e24c0767d3",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | {
"end_col": 53,
"end_line": 85,
"start_col": 0,
"start_line": 71
} | (*
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.Pervasives.fsti.checked",
"Benton2004.RHL.fsti.checked"
],
"interface_file": false,
"source_file": "Benton2004.RHL.Derived.fst"
} | [
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"short_module": null
},
{
"abbrev": false,
"full_module": "Benton2004.RHL",
"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 |
c'': Benton2004.computation ->
c: Benton2004.computation ->
c': Benton2004.computation ->
phi: Benton2004.RHL.gexp Prims.bool ->
phi': Benton2004.RHL.gexp Prims.bool ->
phi'': Benton2004.RHL.gexp Prims.bool
-> FStar.Pervasives.Lemma
(requires
Benton2004.RHL.exec_equiv phi phi' B... | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"Benton2004.computation",
"Benton2004.RHL.gexp",
"Prims.bool",
"Benton2004.RHL.d_su1'",
"Benton2004.RHL.flip",
"Prims.unit",
"Prims.l_and",
"Benton2004.RHL.exec_equiv",
"Benton2004.skip",
"Prims.squash",
"Benton2004.seq",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_... | [] | true | false | true | false | false | let d_su1'_flip (c'' c c': computation) (phi phi' phi'': gexp bool)
: Lemma (requires (exec_equiv phi phi' skip c /\ exec_equiv phi' phi'' c'' c'))
(ensures (exec_equiv phi phi'' c'' (seq c c')))
[
SMTPatOr
[
[SMTPat (exec_equiv phi phi'' c'' (seq c c')); SMTPat (exec_equiv phi... | d_su1' c c' c'' (flip phi) (flip phi') (flip phi'') | false |
Lib.PrintSequence.fst | Lib.PrintSequence.print_label_compare_display | val print_label_compare_display: display:bool -> s:string -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | val print_label_compare_display: display:bool -> s:string -> len:size_nat -> expected:lbytes len -> result:lbytes len -> FStar.All.ML bool | let print_label_compare_display flag s len expected result =
let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag then r
else (
if r then (
IO.print_string "\nSuccess ! ";
IO.print_string s)
else begin
IO.print_string "\nFailure ! ";
IO... | {
"file_name": "lib/Lib.PrintSequence.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 6,
"end_line": 213,
"start_col": 0,
"start_line": 197
} | module Lib.PrintSequence
open FStar.Mul
open Lib.IntTypes
open Lib.RawIntTypes
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
let print_nat8_hex x =
IO.print_uint8 (u8_to_UInt8 (u8 x))
let print_nat8_hex_pad x =
IO.print_uint8_hex_pad (u8_to_UInt8 (u8 x))
let print_nat8_dec x =
IO.print_ui... | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"... | [
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_mo... | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | false |
display: Prims.bool ->
s: Prims.string ->
len: Lib.IntTypes.size_nat ->
expected: Lib.ByteSequence.lbytes len ->
result: Lib.ByteSequence.lbytes len
-> FStar.All.ML Prims.bool | FStar.All.ML | [
"ml"
] | [] | [
"Prims.bool",
"Prims.string",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Prims.unit",
"FStar.IO.print_string",
"FStar.List.iter",
"Lib.IntTypes.uint8",
"Lib.PrintSequence.print_uint8_hex_pad",
"Lib.Sequence.to_list",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
... | [] | false | true | false | false | false | let print_label_compare_display flag s len expected result =
| let r = for_all2 (fun a b -> uint_to_nat #U8 a = uint_to_nat #U8 b) expected result in
if not flag
then r
else
(if r
then
(IO.print_string "\nSuccess ! ";
IO.print_string s)
else
(IO.print_string "\nFailure ! ";
IO.print_string s;
IO.print_newline ();
IO.print_strin... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.