effect stringclasses 48
values | original_source_type stringlengths 0 23k | opens_and_abbrevs listlengths 2 92 | isa_cross_project_example bool 1
class | source_definition stringlengths 9 57.9k | partial_definition stringlengths 7 23.3k | is_div bool 2
classes | is_type null | is_proof bool 2
classes | completed_definiton stringlengths 1 250k | dependencies dict | effect_flags listlengths 0 2 | ideal_premises listlengths 0 236 | mutual_with listlengths 0 11 | file_context stringlengths 0 407k | interleaved bool 1
class | is_simply_typed bool 2
classes | file_name stringlengths 5 48 | vconfig dict | is_simple_lemma null | source_type stringlengths 10 23k | proof_features listlengths 0 1 | name stringlengths 8 95 | source dict | verbose_type stringlengths 1 7.42k | source_range dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val va_quick_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
: (va_quickCode unit (va_code_Keyhash_init win alg)) | [
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.GF128_Mul",
"short_module": null
},
{
"abbrev": false,
"... | false | let va_quick_Keyhash_init (win:bool) (alg:algorithm) (key:(seq nat32)) (roundkeys_b:buffer128)
(hkeys_b:buffer128) : (va_quickCode unit (va_code_Keyhash_init win alg)) =
(va_QProc (va_code_Keyhash_init win alg) ([va_Mod_flags; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm
4; va_Mod_xmm 3; va_Mod_xmm 2; va_Mod_xmm 1; v... | val va_quick_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
: (va_quickCode unit (va_code_Keyhash_init win alg))
let va_quick_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
... | false | null | false | (va_QProc (va_code_Keyhash_init win alg)
([
va_Mod_flags; va_Mod_xmm 6; va_Mod_xmm 5; va_Mod_xmm 4; va_Mod_xmm 3; va_Mod_xmm 2;
va_Mod_xmm 1; va_Mod_xmm 0; va_Mod_mem_layout; va_Mod_mem_heaplet 1; va_Mod_reg64 rR12;
va_Mod_reg64 rR8; va_Mod_reg64 rRdx; va_Mod_reg64 rRcx; va_Mod_reg64 rRax; v... | {
"checked_file": "Vale.AES.X64.GF128_Init.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.... | [
"total"
] | [
"Prims.bool",
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.QuickCode.va_QProc",
"Prims.unit",
"Vale.AES.X64.GF128_Init.va_code_Keyhash_init",
"Prims.Cons",
"Vale.X64.QuickCode.mod_t",
"Vale.X64.QuickCode.va_Mod_flags",
... | [] | module Vale.AES.X64.GF128_Init
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.AES.GF128_s
open Vale.... | false | false | Vale.AES.X64.GF128_Init.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val va_quick_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
: (va_quickCode unit (va_code_Keyhash_init win alg)) | [] | Vale.AES.X64.GF128_Init.va_quick_Keyhash_init | {
"file_name": "obj/Vale.AES.X64.GF128_Init.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
roundkeys_b: Vale.X64.Memory.buffer128 ->
hkeys_b: Vale.X64.Memory.buffer128
-> Vale.X64.QuickCode.va_quickCode Prims.unit
(Vale.AES.X64.GF128_Init.va_code_Keyhash_init win alg) | {
"end_col": 62,
"end_line": 146,
"start_col": 2,
"start_line": 142
} |
Prims.Tot | val va_wp_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.GF128_Mul",
"short_module": null
},
{
"abbrev": false,
"... | false | let va_wp_Keyhash_init (win:bool) (alg:algorithm) (key:(seq nat32)) (roundkeys_b:buffer128)
(hkeys_b:buffer128) (va_s0:va_state) (va_k:(va_state -> unit -> Type0)) : Type0 =
(va_get_ok va_s0 /\ (let (round_ptr:(va_int_range 0 18446744073709551615)) = va_if win (fun _ ->
va_get_reg64 rRcx va_s0) (fun _ -> va_get... | val va_wp_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0
let va_wp_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_... | false | null | false | (va_get_ok va_s0 /\
(let round_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRcx va_s0) (fun _ -> va_get_reg64 rRdi va_s0)
in
let hkey_ptr:(va_int_range 0 18446744073709551615) =
va_if win (fun _ -> va_get_reg64 rRdx va_s0) (fun _ -> va_get_reg64 rRsi va_s0)
in
... | {
"checked_file": "Vale.AES.X64.GF128_Init.fsti.checked",
"dependencies": [
"Vale.X64.State.fsti.checked",
"Vale.X64.QuickCodes.fsti.checked",
"Vale.X64.QuickCode.fst.checked",
"Vale.X64.Memory.fsti.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.InsVector.fsti.checked",
"Vale.X64.... | [
"total"
] | [
"Prims.bool",
"Vale.AES.AES_common_s.algorithm",
"FStar.Seq.Base.seq",
"Vale.X64.Memory.nat32",
"Vale.X64.Memory.buffer128",
"Vale.X64.Decls.va_state",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Vale.X64.Decls.va_get_ok",
"Vale.X64.Memory.is_initial_heap",
"Vale.X64.Decls.va_get_mem_layout",
... | [] | module Vale.AES.X64.GF128_Init
open Vale.Def.Words_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open FStar.Seq
open Vale.Arch.Types
open Vale.Arch.HeapImpl
open Vale.Math.Poly2_s
open Vale.Math.Poly2
open Vale.Math.Poly2.Bits_s
open Vale.Math.Poly2.Bits
open Vale.Math.Poly2.Lemmas
open Vale.AES.GF128_s
open Vale.... | false | true | Vale.AES.X64.GF128_Init.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val va_wp_Keyhash_init
(win: bool)
(alg: algorithm)
(key: (seq nat32))
(roundkeys_b hkeys_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 | [] | Vale.AES.X64.GF128_Init.va_wp_Keyhash_init | {
"file_name": "obj/Vale.AES.X64.GF128_Init.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
win: Prims.bool ->
alg: Vale.AES.AES_common_s.algorithm ->
key: FStar.Seq.Base.seq Vale.X64.Memory.nat32 ->
roundkeys_b: Vale.X64.Memory.buffer128 ->
hkeys_b: Vale.X64.Memory.buffer128 ->
va_s0: Vale.X64.Decls.va_state ->
va_k: (_: Vale.X64.Decls.va_state -> _: Prims.unit -> Type0)
-> Typ... | {
"end_col": 88,
"end_line": 129,
"start_col": 2,
"start_line": 102
} |
Prims.Tot | val bn_mul1_add_in_place_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_add_in_place_f #t #aLen a l acc i c =
mul_wide_add2 a.[i] l c acc.[i] | val bn_mul1_add_in_place_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t
let bn_mul1_add_in_place_f #t #aLen a l acc i c = | false | null | false | mul_wide_add2 a.[ i ] l c acc.[ i ] | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.mul_wide_add2",
"Lib.Sequence.op_String_Access",
"FStar.Pervasives.Native.tuple2"
] | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_add_in_place_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 33,
"end_line": 51,
"start_col": 2,
"start_line": 51
} |
Prims.Tot | val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c | val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t
let bn_mul1_f #t #aLen a l i c = | false | null | false | mul_wide_add a.[ i ] l c | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Base.mul_wide_add",
"Lib.Sequence.op_String_Access",
"FStar.Pervasives.Native.tuple2"
] | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_f | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
i: Lib.IntTypes.size_nat{i < aLen} ->
c: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.limb t | {
"end_col": 24,
"end_line": 26,
"start_col": 2,
"start_line": 26
} |
Prims.Tot | val bn_mul1_add_in_place:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
limb t & lbignum t aLen | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_add_in_place #t #aLen a l acc =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0) | val bn_mul1_add_in_place:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
limb t & lbignum t aLen
let bn_mul1_add_in_place #t #aLen a l acc = | false | null | false | generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0) | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.tup... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_add_in_place:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
limb t & lbignum t aLen | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | {
"end_col": 71,
"end_line": 63,
"start_col": 2,
"start_line": 63
} |
Prims.Tot | val bn_mul1:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
limb t & lbignum t aLen | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1 #t #aLen a l =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0) | val bn_mul1:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
limb t & lbignum t aLen
let bn_mul1 #t #aLen a l = | false | null | false | generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0) | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_f",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.tuple2"
] | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
limb t & lbignum t aLen | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1 | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> l: Hacl.Spec.Bignum.Definitions.limb t
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.lbignum t aLen | {
"end_col": 54,
"end_line": 37,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | val bn_mul1_lshift_add:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> res:lbignum t resLen ->
limb t & lbignum t resLen | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_lshift_add #t #aLen #resLen a b_j j res =
let res' = sub res j aLen in
let c, res' = bn_mul1_add_in_place a b_j res' in
let res = update_sub res j aLen res' in
c, res | val bn_mul1_lshift_add:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> res:lbignum t resLen ->
limb t & lbignum t resLen
let bn_mul1_lshift_add #t #aLen #resLen a b_j j res = | false | null | false | let res' = sub res j aLen in
let c, res' = bn_mul1_add_in_place a b_j res' in
let res = update_sub res j aLen res' in
c, res | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Pervasives.Native.Mktuple2",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"Lib.S... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_lshift_add:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> res:lbignum t resLen ->
limb t & lbignum t resLen | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b_j: Hacl.Spec.Bignum.Definitions.limb t ->
j: Lib.IntTypes.size_nat{j + aLen <= resLen} ->
res: Hacl.Spec.Bignum.Definitions.lbignum t resLen
-> Hacl.Spec.Bignum.Definitions.limb t * Hacl.Spec.Bignum.Definitions.lbignum t resLen | {
"end_col": 8,
"end_line": 80,
"start_col": 53,
"start_line": 76
} |
FStar.Pervasives.Lemma | val bn_mul_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (bn_mul a b) == bn_v a * bn_v b) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul_lemma #t #aLen #bLen a b =
bn_mul_loop_lemma a b bLen | val bn_mul_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (bn_mul a b) == bn_v a * bn_v b)
let bn_mul_lemma #t #aLen #bLen a b = | false | null | true | bn_mul_loop_lemma a b bLen | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Multiplication.bn_mul_loop_lemma",
"Prims.unit"
] | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
Lemma (bn_v (bn_mul a b) == bn_v a * bn_v b) | [] | Hacl.Spec.Bignum.Multiplication.bn_mul_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> FStar.Pervasives.Lemma
(ensures
Hacl.Spec.Bignum.Definitions.bn_v (Hacl.Spec.Bignum.Multiplication.bn_mul a b) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.Definitions.bn_v b) | {
"end_col": 28,
"end_line": 457,
"start_col": 2,
"start_line": 457
} |
FStar.Pervasives.Lemma | val bn_mul1_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
Lemma (let (c, res) = bn_mul1 a l in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a * v l) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_lemma #t #aLen a l =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen | val bn_mul1_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
Lemma (let (c, res) = bn_mul1 a l in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a * v l)
let bn_mul1_lemma #t #aLen a l = | false | null | true | let c, res = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma_loop",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1"
] | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
Lemma (let (c, res) = bn_mul1 a l in
v c * pow2 (bits t * aLen) + bn_v res == bn_v a * v l) | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> l: Hacl.Spec.Bignum.Definitions.limb t
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Multiplication.bn_mul1 a l in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * ... | {
"end_col": 29,
"end_line": 202,
"start_col": 32,
"start_line": 200
} |
Prims.Tot | val bn_mul:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
lbignum t (aLen + bLen) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul #t #aLen #bLen a b =
let res = create (aLen + bLen) (uint #t 0) in
repeati bLen (bn_mul_ a b) res | val bn_mul:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
lbignum t (aLen + bLen)
let bn_mul #t #aLen #bLen a b = | false | null | false | let res = create (aLen + bLen) (uint #t 0) in
repeati bLen (bn_mul_ a b) res | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Lib.LoopCombinators.repeati",
"Hacl.Spec.Bignum.Multiplication.bn_mul_",
"Lib.Sequence.lseq",
"Hacl.Sp... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen ->
lbignum t (aLen + bLen) | [] | Hacl.Spec.Bignum.Multiplication.bn_mul | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + bLen) | {
"end_col": 32,
"end_line": 108,
"start_col": 31,
"start_line": 106
} |
FStar.Pervasives.Lemma | val bn_mul1_add_in_place_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
Lemma (let (c, res) = bn_mul1_add_in_place a l acc in
v c * pow2 (bits t * aLen) + bn_v res == bn_v acc + bn_v a * v l) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_add_in_place_lemma #t #aLen a l acc =
let (c, res) = bn_mul1_add_in_place a l acc in
bn_mul1_add_in_place_lemma_loop a l acc aLen | val bn_mul1_add_in_place_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
Lemma (let (c, res) = bn_mul1_add_in_place a l acc in
v c * pow2 (bits t * aLen) + bn_v res == bn_v acc + bn_v a * v l)
let bn_mul1_add_in_place_lemma #t #aLen a l acc = | false | null | true | let c, res = bn_mul1_add_in_place a l acc in
bn_mul1_add_in_place_lemma_loop a l acc aLen | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma_loop",
"Prims.unit",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_i... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_add_in_place_lemma:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
Lemma (let (c, res) = bn_mul1_add_in_place a l acc in
v c * pow2 (bits t * aLen) + bn_v res == bn_v acc + bn_v a * v l) | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t aLen
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place a l acc in
(let FStar.Pervasives.Native.Mktuple2 ... | {
"end_col": 46,
"end_line": 307,
"start_col": 49,
"start_line": 305
} |
Prims.Tot | val bn_mul_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> res:lbignum t (aLen + bLen) ->
lbignum t (aLen + bLen) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul_ #t #aLen #bLen a b j res =
let c, res = bn_mul1_lshift_add a b.[j] j res in
res.[aLen + j] <- c | val bn_mul_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> res:lbignum t (aLen + bLen) ->
lbignum t (aLen + bLen)
let bn_mul_ #t #aLen #bLen a b j res = | false | null | false | let c, res = bn_mul1_lshift_add a b.[ j ] j res in
res.[ aLen + j ] <- c | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"total"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"Lib.Sequence.op_String_Assignment",
"FStar.P... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> res:lbignum t (aLen + bLen) ->
lbignum t (aLen + bLen) | [] | Hacl.Spec.Bignum.Multiplication.bn_mul_ | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
j: Lib.IntTypes.size_nat{j < bLen} ->
res: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + bLen)
-> Hacl.Spec.Bignum.Definitions.lbignum t (aLen + bLen) | {
"end_col": 21,
"end_line": 95,
"start_col": 38,
"start_line": 93
} |
FStar.Pervasives.Lemma | val bn_mul_lemma_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> acc:lbignum t (aLen + bLen) ->
Lemma (let res = bn_mul_ a b j acc in
v res.[aLen + j] * pow2 (bits t * (aLen + j)) + eval_ (aLen + bLen) res... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul_lemma_ #t #aLen #bLen a b j acc =
let c, res = bn_mul1_lshift_add a b.[j] j acc in
bn_mul1_lshift_add_lemma a b.[j] j acc;
let res1 = res.[aLen + j] <- c in
bn_eval_extensionality_j res res1 (aLen + j) | val bn_mul_lemma_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> acc:lbignum t (aLen + bLen) ->
Lemma (let res = bn_mul_ a b j acc in
v res.[aLen + j] * pow2 (bits t * (aLen + j)) + eval_ (aLen + bLen) res... | false | null | true | let c, res = bn_mul1_lshift_add a b.[ j ] j acc in
bn_mul1_lshift_add_lemma a b.[ j ] j acc;
let res1 = res.[ aLen + j ] <- c in
bn_eval_extensionality_j res res1 (aLen + j) | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_LessThan",
"Hacl.Spec.Bignum.Definitions.limb",
"Hacl.Spec.Bignum.Definitions.bn_eval_extension... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul_lemma_:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> j:size_nat{j < bLen}
-> acc:lbignum t (aLen + bLen) ->
Lemma (let res = bn_mul_ a b j acc in
v res.[aLen + j] * pow2 (bits t * (aLen + j)) + eval_ (aLen + bLen) res... | [] | Hacl.Spec.Bignum.Multiplication.bn_mul_lemma_ | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
j: Lib.IntTypes.size_nat{j < bLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + bLen)
-> FStar.Pervasives.Lemma
(ensures
(let res = Hacl.Spec.Bignum.Multiplication.bn_mul_ a b j acc... | {
"end_col": 46,
"end_line": 376,
"start_col": 44,
"start_line": 371
} |
FStar.Pervasives.Lemma | val bn_mul_loop_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i <= bLen} ->
Lemma (let res = create (aLen + bLen) (uint #t 0) in
let resi = repeati i (bn_mul_ a b) res in
eval_ (aLen + bLen) resi (aLen + i) == bn_v ... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let rec bn_mul_loop_lemma #t #aLen #bLen a b i =
let res = create (aLen + bLen) (uint #t 0) in
let resi = repeati i (bn_mul_ a b) res in
if i = 0 then begin
eq_repeati0 i (bn_mul_ a b) res;
bn_eval0 b;
bn_eval_zeroes #t (aLen + bLen) (aLen + i);
() end
else begin
unfold_repeati i (bn_mul_ a ... | val bn_mul_loop_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i <= bLen} ->
Lemma (let res = create (aLen + bLen) (uint #t 0) in
let resi = repeati i (bn_mul_ a b) res in
eval_ (aLen + bLen) resi (aLen + i) == bn_v ... | false | null | true | let res = create (aLen + bLen) (uint #t 0) in
let resi = repeati i (bn_mul_ a b) res in
if i = 0
then
(eq_repeati0 i (bn_mul_ a b) res;
bn_eval0 b;
bn_eval_zeroes #t (aLen + bLen) (aLen + i);
())
else
(unfold_repeati i (bn_mul_ a b) res (i - 1);
let resi1 = repeati (i - 1) (bn_mul_ a b) res in
a... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval_ze... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul_loop_lemma:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:nat{i <= bLen} ->
Lemma (let res = create (aLen + bLen) (uint #t 0) in
let resi = repeati i (bn_mul_ a b) res in
eval_ (aLen + bLen) resi (aLen + i) == bn_v ... | [
"recursion"
] | Hacl.Spec.Bignum.Multiplication.bn_mul_loop_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
i: Prims.nat{i <= bLen}
-> FStar.Pervasives.Lemma
(ensures
(let res = Lib.Sequence.create (aLen + bLen) (Lib.IntTypes.uint 0) in
let resi =
Lib.LoopCombinators.repeati i (Hacl.S... | {
"end_col": 10,
"end_line": 445,
"start_col": 48,
"start_line": 429
} |
FStar.Pervasives.Lemma | val bn_mul1_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_f a l) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l) | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let rec bn_mul1_lemma_loop #t #aLen a l i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_f a l) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_mul1_f a l) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_ev... | val bn_mul1_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_f a l) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l)
let rec bn_... | false | null | true | let pbits = bits t in
let c, res:generate_elem_a (limb t) (limb t) aLen i =
generate_elems aLen i (bn_mul1_f a l) (uint #t 0)
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_mul1_f a l) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_f a l) (uint #t 0) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l) | [
"recursion"
] | Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma_loop | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen
i
(Hacl.Spec.Bignum.Multiplication.bn_mul1_f a l)
(Lib.... | {
"end_col": 10,
"end_line": 189,
"start_col": 43,
"start_line": 169
} |
FStar.Pervasives.Lemma | val bn_mul1_add_in_place_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
v c * pow2 (bits t * i)... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let rec bn_mul1_add_in_place_lemma_loop #t #aLen a l acc i =
let pbits = bits t in
let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
if i = 0 then begin
eq_generate_elems0 aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0);
ass... | val bn_mul1_add_in_place_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
v c * pow2 (bits t * i)... | false | null | true | let pbits = bits t in
let c, res:generate_elem_a (limb t) (limb t) aLen i =
generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0)
in
if i = 0
then
(eq_generate_elems0 aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.seq",
"Prims.eq2",
"Lib.Sequence.length",
"Prims.op_Equality",
"Prims.int",
"Prims.... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_add_in_place_lemma_loop:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:nat{i <= aLen} ->
Lemma (let (c, res) : generate_elem_a (limb t) (limb t) aLen i = generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
v c * pow2 (bits t * i)... | [
"recursion"
] | Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma_loop | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.nat{i <= aLen}
-> FStar.Pervasives.Lemma
(ensures
(let _ =
Hacl.Spec.Lib.generate_elems aLen
i
(Hacl.Spe... | {
"end_col": 10,
"end_line": 293,
"start_col": 60,
"start_line": 272
} |
FStar.Pervasives.Lemma | val bn_mul_loop_lemma_step:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:pos{i <= bLen}
-> resi1:lbignum t (aLen + bLen) -> Lemma
(requires eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1))
(ensures
... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul_loop_lemma_step #t #aLen #bLen a b i resi1 =
let pbits = bits t in
let resi = bn_mul_ a b (i - 1) resi1 in
bn_mul_lemma_ a b (i - 1) resi1;
assert
(v resi.[aLen + i - 1] * pow2 (pbits * (aLen + i - 1)) + eval_ (aLen + bLen) resi (aLen + i - 1) ==
eval_ (aLen + bLen) resi1 (aLen + i - 1) + bn... | val bn_mul_loop_lemma_step:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:pos{i <= bLen}
-> resi1:lbignum t (aLen + bLen) -> Lemma
(requires eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1))
(ensures
... | false | null | true | let pbits = bits t in
let resi = bn_mul_ a b (i - 1) resi1 in
bn_mul_lemma_ a b (i - 1) resi1;
assert (v resi.[ aLen + i - 1 ] * pow2 (pbits * (aLen + i - 1)) +
eval_ (aLen + bLen) resi (aLen + i - 1) ==
eval_ (aLen + bLen) resi1 (aLen + i - 1) + (bn_v a * v b.[ i - 1 ]) * (pow2 (pbits * (i - 1))));
calc ( == )... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.pos",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Bignum.Definitions.eval_",
"FSta... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul_loop_lemma_step:
#t:limb_t
-> #aLen:size_nat
-> #bLen:size_nat{aLen + bLen <= max_size_t}
-> a:lbignum t aLen
-> b:lbignum t bLen
-> i:pos{i <= bLen}
-> resi1:lbignum t (aLen + bLen) -> Lemma
(requires eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1))
(ensures
... | [] | Hacl.Spec.Bignum.Multiplication.bn_mul_loop_lemma_step | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b: Hacl.Spec.Bignum.Definitions.lbignum t bLen ->
i: Prims.pos{i <= bLen} ->
resi1: Hacl.Spec.Bignum.Definitions.lbignum t (aLen + bLen)
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Bignum.Definitions.eval_ (aLen + bLen) resi1 (aLen + i... | {
"end_col": 73,
"end_line": 415,
"start_col": 55,
"start_line": 392
} |
FStar.Pervasives.Lemma | val bn_mul1_lshift_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> acc:lbignum t resLen ->
Lemma (let (c, res) = bn_mul1_lshift_add a b_j j acc in
v c * pow2 (bits t * (aLen + j)) + eval_ resLen res (aLen + j) ==
e... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_lshift_add_lemma #t #aLen #resLen a b_j j acc =
let pbits = bits t in
let res1 = sub acc j aLen in
let c, res2 = bn_mul1_add_in_place a b_j res1 in
bn_mul1_add_in_place_lemma a b_j res1;
assert (v c * pow2 (pbits * aLen) + bn_v res2 == bn_v res1 + bn_v a * v b_j);
let res = update_sub acc j aLen... | val bn_mul1_lshift_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> acc:lbignum t resLen ->
Lemma (let (c, res) = bn_mul1_lshift_add a b_j j acc in
v c * pow2 (bits t * (aLen + j)) + eval_ resLen res (aLen + j) ==
e... | false | null | true | let pbits = bits t in
let res1 = sub acc j aLen in
let c, res2 = bn_mul1_add_in_place a b_j res1 in
bn_mul1_add_in_place_lemma a b_j res1;
assert (v c * pow2 (pbits * aLen) + bn_v res2 == bn_v res1 + bn_v a * v b_j);
let res = update_sub acc j aLen res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionalit... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.Sequence.eq_intro",
"Prims.op_Subtraction",
"Lib.Sequence.slice",
"Prims.unit",
"Prims... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_lshift_add_lemma:
#t:limb_t
-> #aLen:size_nat
-> #resLen:size_nat
-> a:lbignum t aLen
-> b_j:limb t
-> j:size_nat{j + aLen <= resLen}
-> acc:lbignum t resLen ->
Lemma (let (c, res) = bn_mul1_lshift_add a b_j j acc in
v c * pow2 (bits t * (aLen + j)) + eval_ resLen res (aLen + j) ==
e... | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add_lemma | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
b_j: Hacl.Spec.Bignum.Definitions.limb t ->
j: Lib.IntTypes.size_nat{j + aLen <= resLen} ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t resLen
-> FStar.Pervasives.Lemma
(ensures
(let _ = Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add a b... | {
"end_col": 70,
"end_line": 356,
"start_col": 59,
"start_line": 323
} |
FStar.Pervasives.Lemma | val bn_mul1_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * ... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_lemma_loop_step #t #aLen a l i (c1, res1) =
let pbits = bits t in
let b1 = pow2 (pbits * (i - 1)) in
let b2 = pow2 (pbits * i) in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
let c, e = mul_wide_add a.[i - 1] l c1 in
assert (v e + v c * pow2 pbits == v a.[i - 1] * v... | val bn_mul1_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * ... | false | null | true | let pbits = bits t in
let b1 = pow2 (pbits * (i - 1)) in
let b2 = pow2 (pbits * i) in
let c, res = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
let c, e = mul_wide_add a.[ i - 1 ] l c1 in
assert (v e + v c * pow2 pbits == v a.[ i - 1 ] * v l + v c1);
calc ( == ) {
v c * b2 + bn_v #t #i res;
( == ) { b... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Lib.generate_elem_a",
"Prims.op_Subtraction",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.na... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * ... | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma_loop_step | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
i: Prims.pos{i <= aLen} ->
c1_res1:
Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t)
(Hacl.Spec.Bignum.Definitions.limb t)
aLen
(i - 1)
-> FStar.Pervasives.Lemm... | {
"end_col": 60,
"end_line": 157,
"start_col": 55,
"start_line": 127
} |
FStar.Pervasives.Lemma | val bn_mul1_add_in_place_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i... | [
{
"abbrev": false,
"full_module": "Hacl.Spec.Lib",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum.Definitions",
"short_module": null
},
{
"abbrev": fals... | false | let bn_mul1_add_in_place_lemma_loop_step #t #aLen a l acc i (c1, res1) =
let pbits = bits t in
let b1 = pow2 (pbits * (i - 1)) in
let b2 = pow2 (pbits * i) in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
let c, e = mul_wide_add2 a.[i - 1] l c1 acc.[i - 1] in
as... | val bn_mul1_add_in_place_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i... | false | null | true | let pbits = bits t in
let b1 = pow2 (pbits * (i - 1)) in
let b2 = pow2 (pbits * i) in
let c, res = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
let c, e = mul_wide_add2 a.[ i - 1 ] l c1 acc.[ i - 1 ] in
assert (v e + v c * pow2 pbits == v a.[ i - 1 ] * v l + v c1 + v acc.[ i - 1 ]);
calc ... | {
"checked_file": "Hacl.Spec.Bignum.Multiplication.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Hacl.Spec.Lib.fst.checked",
"Hacl.Spec.Bignum.Definitions.fst.checked",
"Hacl.Spec.Bignum... | [
"lemma"
] | [
"Hacl.Spec.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_nat",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pos",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Lib.generate_elem_a",
"Prims.op_Subtraction",
"Lib.Sequence.seq",
"Prims.eq2",
"Prims.na... | [] | module Hacl.Spec.Bignum.Multiplication
open FStar.Mul
open Lib.IntTypes
open Lib.Sequence
open Lib.LoopCombinators
open Hacl.Spec.Bignum.Definitions
open Hacl.Spec.Bignum.Base
open Hacl.Spec.Lib
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
val bn_mul1_f:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLe... | false | false | Hacl.Spec.Bignum.Multiplication.fst | {
"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... | null | val bn_mul1_add_in_place_lemma_loop_step:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen
-> i:pos{i <= aLen}
-> c1_res1:generate_elem_a (limb t) (limb t) aLen (i - 1) -> Lemma
(requires
(let (c1, res1) = c1_res1 in
v c1 * pow2 (bits t * (i - 1)) + bn_v #t #(i... | [] | Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma_loop_step | {
"file_name": "code/bignum/Hacl.Spec.Bignum.Multiplication.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
l: Hacl.Spec.Bignum.Definitions.limb t ->
acc: Hacl.Spec.Bignum.Definitions.lbignum t aLen ->
i: Prims.pos{i <= aLen} ->
c1_res1:
Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t)
(Hacl.Spec.Bignum.Definitions.limb t)... | {
"end_col": 79,
"end_line": 258,
"start_col": 72,
"start_line": 222
} |
Prims.Tot | val le_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x) | val le_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4}
let le_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} = | false | null | false | n_to_le 4ul (UInt32.v x) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.UInt32.t",
"FStar.Krml.Endianness.n_to_le",
"FStar.UInt32.__uint_to_t",
"FStar.UInt32.v",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} | [] | FStar.Krml.Endianness.le_of_uint32 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | x: FStar.UInt32.t -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} | {
"end_col": 26,
"end_line": 204,
"start_col": 2,
"start_line": 204
} |
Prims.Tot | val le_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x) | val le_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8}
let le_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} = | false | null | false | n_to_le 8ul (UInt64.v x) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.UInt64.t",
"FStar.Krml.Endianness.n_to_le",
"FStar.UInt32.__uint_to_t",
"FStar.UInt64.v",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} | [] | FStar.Krml.Endianness.le_of_uint64 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | x: FStar.UInt64.t -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} | {
"end_col": 26,
"end_line": 224,
"start_col": 2,
"start_line": 224
} |
Prims.Tot | val be_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x) | val be_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8}
let be_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} = | false | null | false | n_to_be 8ul (UInt64.v x) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.UInt64.t",
"FStar.Krml.Endianness.n_to_be",
"FStar.UInt32.__uint_to_t",
"FStar.UInt64.v",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_of_uint64 (x: UInt64.t) : b: bytes{S.length b = 8} | [] | FStar.Krml.Endianness.be_of_uint64 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | x: FStar.UInt64.t -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} | {
"end_col": 26,
"end_line": 234,
"start_col": 2,
"start_line": 234
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let uint64_of_le (b: bytes { S.length b = 8 }) =
let n = le_to_n b in
lemma_le_to_n_is_bounded b;
UInt64.uint_to_t n | let uint64_of_le (b: bytes{S.length b = 8}) = | false | null | false | let n = le_to_n b in
lemma_le_to_n_is_bounded b;
UInt64.uint_to_t n | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.UInt64.uint_to_t",
"Prims.unit",
"FStar.Krml.Endianness.lemma_le_to_n_is_bounded",
"Prims.nat",
"FStar.Krml.Endianness.le_to_n",
"FStar.UInt64.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint64_of_le : b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} -> FStar.UInt64.t | [] | FStar.Krml.Endianness.uint64_of_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} -> FStar.UInt64.t | {
"end_col": 20,
"end_line": 220,
"start_col": 48,
"start_line": 217
} | |
Prims.Tot | val be_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x) | val be_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4}
let be_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} = | false | null | false | n_to_be 4ul (UInt32.v x) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.UInt32.t",
"FStar.Krml.Endianness.n_to_be",
"FStar.UInt32.__uint_to_t",
"FStar.UInt32.v",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_of_uint32 (x: UInt32.t) : b: bytes{S.length b = 4} | [] | FStar.Krml.Endianness.be_of_uint32 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | x: FStar.UInt32.t -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} | {
"end_col": 26,
"end_line": 214,
"start_col": 2,
"start_line": 214
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let uint32_of_le (b: bytes { S.length b = 4 }) =
let n = le_to_n b in
lemma_le_to_n_is_bounded b;
UInt32.uint_to_t n | let uint32_of_le (b: bytes{S.length b = 4}) = | false | null | false | let n = le_to_n b in
lemma_le_to_n_is_bounded b;
UInt32.uint_to_t n | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.UInt32.uint_to_t",
"Prims.unit",
"FStar.Krml.Endianness.lemma_le_to_n_is_bounded",
"Prims.nat",
"FStar.Krml.Endianness.le_to_n",
"FStar.UInt32.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint32_of_le : b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} -> FStar.UInt32.t | [] | FStar.Krml.Endianness.uint32_of_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} -> FStar.UInt32.t | {
"end_col": 20,
"end_line": 200,
"start_col": 48,
"start_line": 197
} | |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let uint32_of_be (b: bytes { S.length b = 4 }) =
let n = be_to_n b in
lemma_be_to_n_is_bounded b;
UInt32.uint_to_t n | let uint32_of_be (b: bytes{S.length b = 4}) = | false | null | false | let n = be_to_n b in
lemma_be_to_n_is_bounded b;
UInt32.uint_to_t n | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.UInt32.uint_to_t",
"Prims.unit",
"FStar.Krml.Endianness.lemma_be_to_n_is_bounded",
"Prims.nat",
"FStar.Krml.Endianness.be_to_n",
"FStar.UInt32.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint32_of_be : b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} -> FStar.UInt32.t | [] | FStar.Krml.Endianness.uint32_of_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4} -> FStar.UInt32.t | {
"end_col": 20,
"end_line": 210,
"start_col": 48,
"start_line": 207
} | |
Prims.Tot | val be_to_n : b:bytes -> Tot nat (decreases (S.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_to_n b =
if S.length b = 0 then 0
else U8.v (S.last b) + pow2 8 * be_to_n (S.slice b 0 (S.length b - 1)) | val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
let rec be_to_n b = | false | null | false | if S.length b = 0 then 0 else U8.v (S.last b) + pow2 8 * be_to_n (S.slice b 0 (S.length b - 1)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.bool",
"Prims.op_Addition",
"FStar.UInt8.v",
"FStar.Seq.Properties.last",
"FStar.Mul.op_Star",
"Prims.pow2",
"FStar.Krml.Endianness.be_to_n",
"FStar.Seq.Base.slice",
"Prims.op_... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | true | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_to_n : b:bytes -> Tot nat (decreases (S.length b)) | [
"recursion"
] | FStar.Krml.Endianness.be_to_n | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> Prims.Tot Prims.nat | {
"end_col": 72,
"end_line": 30,
"start_col": 2,
"start_line": 29
} |
Prims.Tot | val le_to_n : b:bytes -> Tot nat (decreases (S.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec le_to_n b =
if S.length b = 0 then 0
else U8.v (S.head b) + pow2 8 * le_to_n (S.tail b) | val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
let rec le_to_n b = | false | null | false | if S.length b = 0 then 0 else U8.v (S.head b) + pow2 8 * le_to_n (S.tail b) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.bool",
"Prims.op_Addition",
"FStar.UInt8.v",
"FStar.Seq.Properties.head",
"FStar.Mul.op_Star",
"Prims.pow2",
"FStar.Krml.Endianness.le_to_n",
"FStar.Seq.Properties.tail",
"Prim... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | true | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_to_n : b:bytes -> Tot nat (decreases (S.length b)) | [
"recursion"
] | FStar.Krml.Endianness.le_to_n | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> Prims.Tot Prims.nat | {
"end_col": 52,
"end_line": 23,
"start_col": 2,
"start_line": 22
} |
Prims.Tot | val be_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_of_seq_uint32 (s: S.seq UInt32.t):
Tot (b:bytes { S.length b = 4 * S.length s })
(decreases (S.length s))
=
if S.length s = 0 then
S.empty
else
S.append (be_of_uint32 (S.head s)) (be_of_seq_uint32 (S.tail s)) | val be_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s))
let rec be_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) = | false | null | false | if S.length s = 0 then S.empty else S.append (be_of_uint32 (S.head s)) (be_of_seq_uint32 (S.tail s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Krml.Endianness.be_of_uint32",
"FStar.Seq.Properties.head",
"FStar.Krml.Endianness.be_of_seq_uint32",
"FSt... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) | [
"recursion"
] | FStar.Krml.Endianness.be_of_seq_uint32 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: FStar.Seq.Base.seq FStar.UInt32.t
-> Prims.Tot
(b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4 * FStar.Seq.Base.length s}) | {
"end_col": 68,
"end_line": 274,
"start_col": 2,
"start_line": 271
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let uint64_of_be (b: bytes { S.length b = 8 }) =
let n = be_to_n b in
lemma_be_to_n_is_bounded b;
UInt64.uint_to_t n | let uint64_of_be (b: bytes{S.length b = 8}) = | false | null | false | let n = be_to_n b in
lemma_be_to_n_is_bounded b;
UInt64.uint_to_t n | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.UInt64.uint_to_t",
"Prims.unit",
"FStar.Krml.Endianness.lemma_be_to_n_is_bounded",
"Prims.nat",
"FStar.Krml.Endianness.be_to_n",
"FStar.UInt64.t"
] | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val uint64_of_be : b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} -> FStar.UInt64.t | [] | FStar.Krml.Endianness.uint64_of_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8} -> FStar.UInt64.t | {
"end_col": 20,
"end_line": 230,
"start_col": 48,
"start_line": 227
} | |
FStar.Pervasives.Lemma | val n_to_be_be_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(be_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_be len (be_to_n s) == s))
[SMTPat (n_to_be len (be_to_n s))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let n_to_be_be_to_n (len: U32.t) (s: Seq.seq U8.t) : Lemma
(requires (Seq.length s == U32.v len))
(ensures (
be_to_n s < pow2 (8 `Prims.op_Multiply` U32.v len) /\
n_to_be len (be_to_n s) == s
))
[SMTPat (n_to_be len (be_to_n s))]
= lemma_be_to_n_is_bounded s;
be_to_n_inj s (n_to_be len (be_to_n s)) | val n_to_be_be_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(be_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_be len (be_to_n s) == s))
[SMTPat (n_to_be len (be_to_n s))]
let n_to_be_be_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (re... | false | null | true | lemma_be_to_n_is_bounded s;
be_to_n_inj s (n_to_be len (be_to_n s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma"
] | [
"FStar.UInt32.t",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Krml.Endianness.be_to_n_inj",
"FStar.Krml.Endianness.n_to_be",
"FStar.Krml.Endianness.be_to_n",
"Prims.unit",
"FStar.Krml.Endianness.lemma_be_to_n_is_bounded",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Great... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val n_to_be_be_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(be_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_be len (be_to_n s) == s))
[SMTPat (n_to_be len (be_to_n s))] | [] | FStar.Krml.Endianness.n_to_be_be_to_n | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | len: FStar.UInt32.t -> s: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length s == FStar.UInt32.v len)
(ensures
FStar.Krml.Endianness.be_to_n s < Prims.pow2 (8 * FStar.UInt32.v len) /\
FStar.Krml.Endianness.n_to_be len (FStar.Krml.Endianness.be_to_n s) == s... | {
"end_col": 41,
"end_line": 181,
"start_col": 2,
"start_line": 180
} |
Prims.Tot | val be_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_of_seq_uint64 (s: S.seq UInt64.t):
Tot (b:bytes { S.length b = 8 * S.length s })
(decreases (S.length s))
=
if S.length s = 0 then
S.empty
else
S.append (be_of_uint64 (S.head s)) (be_of_seq_uint64 (S.tail s)) | val be_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s))
let rec be_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) = | false | null | false | if S.length s = 0 then S.empty else S.append (be_of_uint64 (S.head s)) (be_of_seq_uint64 (S.tail s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt64.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Krml.Endianness.be_of_uint64",
"FStar.Seq.Properties.head",
"FStar.Krml.Endianness.be_of_seq_uint64",
"FSt... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) | [
"recursion"
] | FStar.Krml.Endianness.be_of_seq_uint64 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: FStar.Seq.Base.seq FStar.UInt64.t
-> Prims.Tot
(b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8 * FStar.Seq.Base.length s}) | {
"end_col": 68,
"end_line": 314,
"start_col": 2,
"start_line": 311
} |
FStar.Pervasives.Lemma | val n_to_le_le_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(le_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_le len (le_to_n s) == s))
[SMTPat (n_to_le len (le_to_n s))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let n_to_le_le_to_n (len: U32.t) (s: Seq.seq U8.t) : Lemma
(requires (Seq.length s == U32.v len))
(ensures (
le_to_n s < pow2 (8 `Prims.op_Multiply` U32.v len) /\
n_to_le len (le_to_n s) == s
))
[SMTPat (n_to_le len (le_to_n s))]
= lemma_le_to_n_is_bounded s;
le_to_n_inj s (n_to_le len (le_to_n s)) | val n_to_le_le_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(le_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_le len (le_to_n s) == s))
[SMTPat (n_to_le len (le_to_n s))]
let n_to_le_le_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (re... | false | null | true | lemma_le_to_n_is_bounded s;
le_to_n_inj s (n_to_le len (le_to_n s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma"
] | [
"FStar.UInt32.t",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"FStar.Krml.Endianness.le_to_n_inj",
"FStar.Krml.Endianness.n_to_le",
"FStar.Krml.Endianness.le_to_n",
"Prims.unit",
"FStar.Krml.Endianness.lemma_le_to_n_is_bounded",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.b2t",
"Prims.op_Great... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val n_to_le_le_to_n (len: U32.t) (s: Seq.seq U8.t)
: Lemma (requires (Seq.length s == U32.v len))
(ensures
(le_to_n s < pow2 (8 `Prims.op_Multiply` (U32.v len)) /\ n_to_le len (le_to_n s) == s))
[SMTPat (n_to_le len (le_to_n s))] | [] | FStar.Krml.Endianness.n_to_le_le_to_n | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | len: FStar.UInt32.t -> s: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length s == FStar.UInt32.v len)
(ensures
FStar.Krml.Endianness.le_to_n s < Prims.pow2 (8 * FStar.UInt32.v len) /\
FStar.Krml.Endianness.n_to_le len (FStar.Krml.Endianness.le_to_n s) == s... | {
"end_col": 41,
"end_line": 192,
"start_col": 2,
"start_line": 191
} |
Prims.Tot | val le_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec le_of_seq_uint32 (s: S.seq UInt32.t):
Tot (b:bytes { S.length b = 4 * S.length s })
(decreases (S.length s))
=
if S.length s = 0 then
S.empty
else
S.append (le_of_uint32 (S.head s)) (le_of_seq_uint32 (S.tail s)) | val le_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s))
let rec le_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) = | false | null | false | if S.length s = 0 then S.empty else S.append (le_of_uint32 (S.head s)) (le_of_seq_uint32 (S.tail s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Krml.Endianness.le_of_uint32",
"FStar.Seq.Properties.head",
"FStar.Krml.Endianness.le_of_seq_uint32",
"FSt... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_of_seq_uint32 (s: S.seq UInt32.t)
: Tot (b: bytes{S.length b = 4 * S.length s}) (decreases (S.length s)) | [
"recursion"
] | FStar.Krml.Endianness.le_of_seq_uint32 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: FStar.Seq.Base.seq FStar.UInt32.t
-> Prims.Tot
(b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4 * FStar.Seq.Base.length s}) | {
"end_col": 68,
"end_line": 254,
"start_col": 2,
"start_line": 251
} |
FStar.Pervasives.Lemma | val be_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ be_to_n b1 == be_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_to_n_inj
(b1 b2: Seq.seq U8.t)
: Lemma
(requires (Seq.length b1 == Seq.length b2 /\ be_to_n b1 == be_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1))
= if Seq.length b1 = 0
then ()
else begin
be_to_n_inj (Seq.slice b1 0 (Seq.length b1 - 1)) (Seq.slice b2 0 (Seq.length b2 - 1)... | val be_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ be_to_n b1 == be_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1))
let rec be_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ be_to_n b1 == be_to_n b2))
... | false | null | true | if Seq.length b1 = 0
then ()
else
(be_to_n_inj (Seq.slice b1 0 (Seq.length b1 - 1)) (Seq.slice b2 0 (Seq.length b2 - 1));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.lemma_split",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Krml.Endianness.be_to_n_inj",
"FStar.Seq.Base.slice",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val be_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ be_to_n b1 == be_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) | [
"recursion"
] | FStar.Krml.Endianness.be_to_n_inj | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b1: FStar.Seq.Base.seq FStar.UInt8.t -> b2: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length b1 == FStar.Seq.Base.length b2 /\
FStar.Krml.Endianness.be_to_n b1 == FStar.Krml.Endianness.be_to_n b2)
(ensures FStar.Seq.Base.equal b1 b2)
(decreas... | {
"end_col": 5,
"end_line": 155,
"start_col": 2,
"start_line": 149
} |
Prims.Tot | val seq_uint32_of_be (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec seq_uint32_of_be (l: nat) (b: bytes{ S.length b = 4 * l }):
s:S.seq UInt32.t { S.length s = l }
=
if S.length b = 0 then
S.empty
else
let hd, tl = Seq.split b 4 in
S.cons (uint32_of_be hd) (seq_uint32_of_be (l - 1) tl) | val seq_uint32_of_be (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l}
let rec seq_uint32_of_be (l: nat) (b: bytes{S.length b = 4 * l})
: s: S.seq UInt32.t {S.length s = l} = | false | null | false | if S.length b = 0
then S.empty
else
let hd, tl = Seq.split b 4 in
S.cons (uint32_of_be hd) (seq_uint32_of_be (l - 1) tl) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"Prims.nat",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Mul.op_Star",
"FStar.Seq.Base.empty",
"FStar.UInt32.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.cons",
"FStar.Krml.Endianness.uint32... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val seq_uint32_of_be (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l} | [
"recursion"
] | FStar.Krml.Endianness.seq_uint32_of_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | l: Prims.nat -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4 * l}
-> s: FStar.Seq.Base.seq FStar.UInt32.t {FStar.Seq.Base.length s = l} | {
"end_col": 58,
"end_line": 264,
"start_col": 2,
"start_line": 260
} |
Prims.Tot | val seq_uint64_of_be (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec seq_uint64_of_be (l: nat) (b: bytes{ S.length b = 8 * l }):
s:S.seq UInt64.t { S.length s = l }
=
if S.length b = 0 then
S.empty
else
let hd, tl = Seq.split b 8 in
S.cons (uint64_of_be hd) (seq_uint64_of_be (l - 1) tl) | val seq_uint64_of_be (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l}
let rec seq_uint64_of_be (l: nat) (b: bytes{S.length b = 8 * l})
: s: S.seq UInt64.t {S.length s = l} = | false | null | false | if S.length b = 0
then S.empty
else
let hd, tl = Seq.split b 8 in
S.cons (uint64_of_be hd) (seq_uint64_of_be (l - 1) tl) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"Prims.nat",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Mul.op_Star",
"FStar.Seq.Base.empty",
"FStar.UInt64.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.cons",
"FStar.Krml.Endianness.uint64... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val seq_uint64_of_be (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l} | [
"recursion"
] | FStar.Krml.Endianness.seq_uint64_of_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | l: Prims.nat -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8 * l}
-> s: FStar.Seq.Base.seq FStar.UInt64.t {FStar.Seq.Base.length s = l} | {
"end_col": 58,
"end_line": 304,
"start_col": 2,
"start_line": 300
} |
Prims.Tot | val le_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec le_of_seq_uint64 (s: S.seq UInt64.t):
Tot (b:bytes { S.length b = 8 * S.length s })
(decreases (S.length s))
=
if S.length s = 0 then
S.empty
else
S.append (le_of_uint64 (S.head s)) (le_of_seq_uint64 (S.tail s)) | val le_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s))
let rec le_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) = | false | null | false | if S.length s = 0 then S.empty else S.append (le_of_uint64 (S.head s)) (le_of_seq_uint64 (S.tail s)) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt64.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Seq.Base.append",
"FStar.Krml.Endianness.le_of_uint64",
"FStar.Seq.Properties.head",
"FStar.Krml.Endianness.le_of_seq_uint64",
"FSt... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_of_seq_uint64 (s: S.seq UInt64.t)
: Tot (b: bytes{S.length b = 8 * S.length s}) (decreases (S.length s)) | [
"recursion"
] | FStar.Krml.Endianness.le_of_seq_uint64 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: FStar.Seq.Base.seq FStar.UInt64.t
-> Prims.Tot
(b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8 * FStar.Seq.Base.length s}) | {
"end_col": 68,
"end_line": 294,
"start_col": 2,
"start_line": 291
} |
FStar.Pervasives.Lemma | val be_of_seq_uint32_slice (s: S.seq U32.t) (lo hi: nat)
: Lemma (requires (lo <= hi /\ hi <= S.length s))
(ensures
((be_of_seq_uint32 (S.slice s lo hi))
`S.equal`
(S.slice (be_of_seq_uint32 s) (4 * lo) (4 * hi)))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let be_of_seq_uint32_slice (s: S.seq U32.t) (lo: nat) (hi: nat) : Lemma
(requires (lo <= hi /\ hi <= S.length s))
(ensures (be_of_seq_uint32 (S.slice s lo hi) `S.equal` S.slice (be_of_seq_uint32 s) (4 * lo) (4 * hi)))
= slice_seq_uint32_of_be (S.length s) (be_of_seq_uint32 s) lo hi | val be_of_seq_uint32_slice (s: S.seq U32.t) (lo hi: nat)
: Lemma (requires (lo <= hi /\ hi <= S.length s))
(ensures
((be_of_seq_uint32 (S.slice s lo hi))
`S.equal`
(S.slice (be_of_seq_uint32 s) (4 * lo) (4 * hi))))
let be_of_seq_uint32_slice (s: S.seq U32.t) (lo hi: nat)
: Lemm... | false | null | true | slice_seq_uint32_of_be (S.length s) (be_of_seq_uint32 s) lo hi | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma"
] | [
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.nat",
"FStar.Krml.Endianness.slice_seq_uint32_of_be",
"FStar.Seq.Base.length",
"FStar.Krml.Endianness.be_of_seq_uint32",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.squash",
"FStar.Seq.Base.equal",
"FStar.UInt8.t... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val be_of_seq_uint32_slice (s: S.seq U32.t) (lo hi: nat)
: Lemma (requires (lo <= hi /\ hi <= S.length s))
(ensures
((be_of_seq_uint32 (S.slice s lo hi))
`S.equal`
(S.slice (be_of_seq_uint32 s) (4 * lo) (4 * hi)))) | [] | FStar.Krml.Endianness.be_of_seq_uint32_slice | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s: FStar.Seq.Base.seq FStar.UInt32.t -> lo: Prims.nat -> hi: Prims.nat
-> FStar.Pervasives.Lemma (requires lo <= hi /\ hi <= FStar.Seq.Base.length s)
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.be_of_seq_uint32 (FStar.Seq.Base.slice s lo hi))
(FStar.Seq.Base.slice (FStar.Krml.Endianne... | {
"end_col": 64,
"end_line": 560,
"start_col": 2,
"start_line": 560
} |
FStar.Pervasives.Lemma | val le_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ le_to_n b1 == le_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec le_to_n_inj
(b1 b2: Seq.seq U8.t)
: Lemma
(requires (Seq.length b1 == Seq.length b2 /\ le_to_n b1 == le_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1))
= if Seq.length b1 = 0
then ()
else begin
le_to_n_inj (Seq.slice b1 1 (Seq.length b1)) (Seq.slice b2 1 (Seq.length b2));
S... | val le_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ le_to_n b1 == le_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1))
let rec le_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ le_to_n b1 == le_to_n b2))
... | false | null | true | if Seq.length b1 = 0
then ()
else
(le_to_n_inj (Seq.slice b1 1 (Seq.length b1)) (Seq.slice b2 1 (Seq.length b2));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.bool",
"FStar.Seq.Properties.lemma_split",
"Prims.unit",
"FStar.Krml.Endianness.le_to_n_inj",
"FStar.Seq.Base.slice",
"Prims.l_and",
"Prims.eq2",
"Prims.nat",
"FStar.Krml.Endianness.le_... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val le_to_n_inj (b1 b2: Seq.seq U8.t)
: Lemma (requires (Seq.length b1 == Seq.length b2 /\ le_to_n b1 == le_to_n b2))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) | [
"recursion"
] | FStar.Krml.Endianness.le_to_n_inj | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b1: FStar.Seq.Base.seq FStar.UInt8.t -> b2: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length b1 == FStar.Seq.Base.length b2 /\
FStar.Krml.Endianness.le_to_n b1 == FStar.Krml.Endianness.le_to_n b2)
(ensures FStar.Seq.Base.equal b1 b2)
(decreas... | {
"end_col": 5,
"end_line": 170,
"start_col": 2,
"start_line": 164
} |
Prims.Tot | val seq_uint64_of_le (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec seq_uint64_of_le (l: nat) (b: bytes{ S.length b = 8 * l }):
s:S.seq UInt64.t { S.length s = l }
=
if S.length b = 0 then
S.empty
else
let hd, tl = Seq.split b 8 in
S.cons (uint64_of_le hd) (seq_uint64_of_le (l - 1) tl) | val seq_uint64_of_le (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l}
let rec seq_uint64_of_le (l: nat) (b: bytes{S.length b = 8 * l})
: s: S.seq UInt64.t {S.length s = l} = | false | null | false | if S.length b = 0
then S.empty
else
let hd, tl = Seq.split b 8 in
S.cons (uint64_of_le hd) (seq_uint64_of_le (l - 1) tl) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"Prims.nat",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Mul.op_Star",
"FStar.Seq.Base.empty",
"FStar.UInt64.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.cons",
"FStar.Krml.Endianness.uint64... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val seq_uint64_of_le (l: nat) (b: bytes{S.length b = 8 * l}) : s: S.seq UInt64.t {S.length s = l} | [
"recursion"
] | FStar.Krml.Endianness.seq_uint64_of_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | l: Prims.nat -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 8 * l}
-> s: FStar.Seq.Base.seq FStar.UInt64.t {FStar.Seq.Base.length s = l} | {
"end_col": 58,
"end_line": 284,
"start_col": 2,
"start_line": 280
} |
Prims.Tot | val seq_uint32_of_le (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l} | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec seq_uint32_of_le (l: nat) (b: bytes{ S.length b = 4 * l }):
s:S.seq UInt32.t { S.length s = l }
=
if S.length b = 0 then
S.empty
else
let hd, tl = Seq.split b 4 in
S.cons (uint32_of_le hd) (seq_uint32_of_le (l - 1) tl) | val seq_uint32_of_le (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l}
let rec seq_uint32_of_le (l: nat) (b: bytes{S.length b = 4 * l})
: s: S.seq UInt32.t {S.length s = l} = | false | null | false | if S.length b = 0
then S.empty
else
let hd, tl = Seq.split b 4 in
S.cons (uint32_of_le hd) (seq_uint32_of_le (l - 1) tl) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total"
] | [
"Prims.nat",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Mul.op_Star",
"FStar.Seq.Base.empty",
"FStar.UInt32.t",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.cons",
"FStar.Krml.Endianness.uint32... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val seq_uint32_of_le (l: nat) (b: bytes{S.length b = 4 * l}) : s: S.seq UInt32.t {S.length s = l} | [
"recursion"
] | FStar.Krml.Endianness.seq_uint32_of_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | l: Prims.nat -> b: FStar.Krml.Endianness.bytes{FStar.Seq.Base.length b = 4 * l}
-> s: FStar.Seq.Base.seq FStar.UInt32.t {FStar.Seq.Base.length s = l} | {
"end_col": 58,
"end_line": 244,
"start_col": 2,
"start_line": 240
} |
FStar.Pervasives.Lemma | val lemma_be_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (be_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec lemma_be_to_n_is_bounded b =
if Seq.length b = 0 then ()
else
begin
let s = Seq.slice b 0 (Seq.length b - 1) in
assert(Seq.length s = Seq.length b - 1);
lemma_be_to_n_is_bounded s;
assert(UInt8.v (Seq.last b) < pow2 8);
assert(be_to_n s < pow2 (8 * Seq.length s));
assert(be_to_n ... | val lemma_be_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (be_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b))
let rec lemma_be_to_n_is_bounded b = | false | null | true | if Seq.length b = 0
then ()
else
let s = Seq.slice b 0 (Seq.length b - 1) in
assert (Seq.length s = Seq.length b - 1);
lemma_be_to_n_is_bounded s;
assert (UInt8.v (Seq.last b) < pow2 8);
assert (be_to_n s < pow2 (8 * Seq.length s));
assert (be_to_n b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lem... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Krml.Endianness.lemma_factorise",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Mul.op_Star",
"Prims._assert",
"Prims.b2t",
"Prims.o... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_be_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (be_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b)) | [
"recursion"
] | FStar.Krml.Endianness.lemma_be_to_n_is_bounded | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes
-> FStar.Pervasives.Lemma
(ensures FStar.Krml.Endianness.be_to_n b < Prims.pow2 (8 * FStar.Seq.Base.length b))
(decreases FStar.Seq.Base.length b) | {
"end_col": 7,
"end_line": 84,
"start_col": 2,
"start_line": 70
} |
Prims.Tot | val n_to_be:
len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == be_to_n b})
(decreases (U32.v len)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec n_to_be len n =
if len = 0ul then
S.empty
else
let len = U32.(len -^ 1ul) in
let byte = U8.uint_to_t (n % 256) in
let n' = n / 256 in
Math.pow2_plus 8 (8 * U32.v len);
assert(n' < pow2 (8 * U32.v len ));
let b' = n_to_be len n' in
let b'' = S.create 1 byte in
let b = S.ap... | val n_to_be:
len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == be_to_n b})
(decreases (U32.v len))
let rec n_to_be len n = | false | null | false | if len = 0ul
then S.empty
else
let len = let open U32 in len -^ 1ul in
let byte = U8.uint_to_t (n % 256) in
let n' = n / 256 in
Math.pow2_plus 8 (8 * U32.v len);
assert (n' < pow2 (8 * U32.v len));
let b' = n_to_be len n' in
let b'' = S.create 1 byte in
let b = S.append b' b'' in
S.lemma_eq_intro b' (... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.UInt32.t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"FStar.UInt32.v",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Seq.Base.sli... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val n_to_be:
len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == be_to_n b})
(decreases (U32.v len)) | [
"recursion"
] | FStar.Krml.Endianness.n_to_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | len: FStar.UInt32.t -> n: Prims.nat{n < Prims.pow2 (8 * FStar.UInt32.v len)}
-> Prims.Tot
(b:
FStar.Krml.Endianness.bytes
{FStar.Seq.Base.length b == FStar.UInt32.v len /\ n == FStar.Krml.Endianness.be_to_n b}) | {
"end_col": 5,
"end_line": 126,
"start_col": 2,
"start_line": 114
} |
FStar.Pervasives.Lemma | val lemma_le_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (le_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec lemma_le_to_n_is_bounded b =
if Seq.length b = 0 then ()
else
begin
let s = Seq.slice b 1 (Seq.length b) in
assert(Seq.length s = Seq.length b - 1);
lemma_le_to_n_is_bounded s;
assert(UInt8.v (Seq.index b 0) < pow2 8);
assert(le_to_n s < pow2 (8 * Seq.length s));
assert(le_to_n b... | val lemma_le_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (le_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b))
let rec lemma_le_to_n_is_bounded b = | false | null | true | if Seq.length b = 0
then ()
else
let s = Seq.slice b 1 (Seq.length b) in
assert (Seq.length s = Seq.length b - 1);
lemma_le_to_n_is_bounded s;
assert (UInt8.v (Seq.index b 0) < pow2 8);
assert (le_to_n s < pow2 (8 * Seq.length s));
assert (le_to_n b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemm... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.bool",
"FStar.Krml.Endianness.lemma_factorise",
"Prims.op_Subtraction",
"Prims.unit",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Mul.op_Star",
"Prims._assert",
"Prims.b2t",
"Prims.o... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_le_to_n_is_bounded: b:bytes -> Lemma
(requires True)
(ensures (le_to_n b < pow2 (8 * Seq.length b)))
(decreases (Seq.length b)) | [
"recursion"
] | FStar.Krml.Endianness.lemma_le_to_n_is_bounded | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes
-> FStar.Pervasives.Lemma
(ensures FStar.Krml.Endianness.le_to_n b < Prims.pow2 (8 * FStar.Seq.Base.length b))
(decreases FStar.Seq.Base.length b) | {
"end_col": 7,
"end_line": 62,
"start_col": 2,
"start_line": 48
} |
FStar.Pervasives.Lemma | val seq_uint32_of_be_be_of_seq_uint32 (n: nat) (s: S.seq U32.t)
: Lemma (requires (n == S.length s))
(ensures ((seq_uint32_of_be n (be_of_seq_uint32 s)) `S.equal` s))
(decreases n)
[SMTPat (seq_uint32_of_be n (be_of_seq_uint32 s))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec seq_uint32_of_be_be_of_seq_uint32 (n: nat) (s: S.seq U32.t) : Lemma
(requires (n == S.length s))
(ensures (seq_uint32_of_be n (be_of_seq_uint32 s) `S.equal` s))
(decreases n)
[SMTPat (seq_uint32_of_be n (be_of_seq_uint32 s))]
= if n = 0
then ()
else begin
assert (s `S.equal` S.cons (S.head s) (S... | val seq_uint32_of_be_be_of_seq_uint32 (n: nat) (s: S.seq U32.t)
: Lemma (requires (n == S.length s))
(ensures ((seq_uint32_of_be n (be_of_seq_uint32 s)) `S.equal` s))
(decreases n)
[SMTPat (seq_uint32_of_be n (be_of_seq_uint32 s))]
let rec seq_uint32_of_be_be_of_seq_uint32 (n: nat) (s: S.seq U32.t... | false | null | true | if n = 0
then ()
else
(assert (s `S.equal` (S.cons (S.head s) (S.tail s)));
seq_uint32_of_be_be_of_seq_uint32 (n - 1) (S.tail s);
let s' = be_of_seq_uint32 s in
S.lemma_split s' 4;
S.lemma_append_inj (S.slice s' 0 4)
(S.slice s' 4 (S.length s'))
(be_of_uint32 (S.head s))
(be_of_seq_u... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.UInt8.t",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"FStar.Krml.Endianness.be_of_uint32",
"FStar.Seq.Properties.head",
"FStar.Krml.Endia... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val seq_uint32_of_be_be_of_seq_uint32 (n: nat) (s: S.seq U32.t)
: Lemma (requires (n == S.length s))
(ensures ((seq_uint32_of_be n (be_of_seq_uint32 s)) `S.equal` s))
(decreases n)
[SMTPat (seq_uint32_of_be n (be_of_seq_uint32 s))] | [
"recursion"
] | FStar.Krml.Endianness.seq_uint32_of_be_be_of_seq_uint32 | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | n: Prims.nat -> s: FStar.Seq.Base.seq FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires n == FStar.Seq.Base.length s)
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.seq_uint32_of_be n
(FStar.Krml.Endianness.be_of_seq_uint32 s))
s)
(decreases n)
[SMTPat (FStar.K... | {
"end_col": 5,
"end_line": 526,
"start_col": 2,
"start_line": 518
} |
Prims.Tot | val n_to_le : len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == le_to_n b})
(decreases (U32.v len)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec n_to_le len n =
if len = 0ul then
S.empty
else
let len = U32.(len -^ 1ul) in
let byte = U8.uint_to_t (n % 256) in
let n' = n / 256 in
Math.pow2_plus 8 (8 * U32.v len);
assert(n' < pow2 (8 * U32.v len ));
let b' = n_to_le len n' in
let b = S.cons byte b' in
S.lemma_eq_intr... | val n_to_le : len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == le_to_n b})
(decreases (U32.v len))
let rec n_to_le len n = | false | null | false | if len = 0ul
then S.empty
else
let len = let open U32 in len -^ 1ul in
let byte = U8.uint_to_t (n % 256) in
let n' = n / 256 in
Math.pow2_plus 8 (8 * U32.v len);
assert (n' < pow2 (8 * U32.v len));
let b' = n_to_le len n' in
let b = S.cons byte b' in
S.lemma_eq_intro b' (S.tail b);
b | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"total",
""
] | [
"FStar.UInt32.t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"FStar.UInt32.v",
"Prims.op_Equality",
"FStar.UInt32.__uint_to_t",
"FStar.Seq.Base.empty",
"FStar.UInt8.t",
"Prims.bool",
"Prims.unit",
"FStar.Seq.Base.lemma_eq_intro",
"FStar.Seq.Properti... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val n_to_le : len:U32.t -> n:nat{n < pow2 (8 * U32.v len)} ->
Tot (b:bytes{S.length b == U32.v len /\ n == le_to_n b})
(decreases (U32.v len)) | [
"recursion"
] | FStar.Krml.Endianness.n_to_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | len: FStar.UInt32.t -> n: Prims.nat{n < Prims.pow2 (8 * FStar.UInt32.v len)}
-> Prims.Tot
(b:
FStar.Krml.Endianness.bytes
{FStar.Seq.Base.length b == FStar.UInt32.v len /\ n == FStar.Krml.Endianness.le_to_n b}) | {
"end_col": 5,
"end_line": 104,
"start_col": 2,
"start_line": 93
} |
FStar.Pervasives.Lemma | val offset_uint32_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_be n b) i == uint32_of_be (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_be n b) i)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec offset_uint32_be (b: bytes) (n: nat) (i: nat):
Lemma
(requires (
S.length b = 4 * n /\
i < n))
(ensures (
S.index (seq_uint32_of_be n b) i == uint32_of_be (S.slice b (4 * i) (4 * i + 4))))
(decreases (
S.length b))
[ SMTPat (S.index (seq_uint32_of_be n b) i) ]
=
if S.... | val offset_uint32_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_be n b) i == uint32_of_be (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_be n b) i)]
let rec offset_uint32_be (b: bytes) (n i: na... | false | null | true | if S.length b = 0
then false_elim ()
else
let hd, tl = Seq.split b 4 in
if i = 0 then () else offset_uint32_be tl (n - 1) (i - 1) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Pervasives.false_elim",
"Prims.unit",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Krml.Endianness.offset_uint32_be",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val offset_uint32_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_be n b) i == uint32_of_be (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_be n b) i)] | [
"recursion"
] | FStar.Krml.Endianness.offset_uint32_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> n: Prims.nat -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b = 4 * n /\ i < n)
(ensures
FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint32_of_be n b) i ==
FStar.Krml.Endianness.uint32_of_be (FStar.Seq.Base.slice b (4 * i) (4 * i +... | {
"end_col": 41,
"end_line": 338,
"start_col": 2,
"start_line": 331
} |
FStar.Pervasives.Lemma | val offset_uint64_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_be n b) i == uint64_of_be (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_be n b) i)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec offset_uint64_be (b: bytes) (n: nat) (i: nat):
Lemma
(requires (
S.length b = 8 * n /\
i < n))
(ensures (
S.index (seq_uint64_of_be n b) i == uint64_of_be (S.slice b (8 * i) (8 * i + 8))))
(decreases (
S.length b))
[ SMTPat (S.index (seq_uint64_of_be n b) i) ]
=
if S.... | val offset_uint64_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_be n b) i == uint64_of_be (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_be n b) i)]
let rec offset_uint64_be (b: bytes) (n i: na... | false | null | true | if S.length b = 0
then false_elim ()
else
let hd, tl = Seq.split b 8 in
if i = 0 then () else offset_uint64_be tl (n - 1) (i - 1) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Pervasives.false_elim",
"Prims.unit",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Krml.Endianness.offset_uint64_be",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val offset_uint64_be (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_be n b) i == uint64_of_be (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_be n b) i)] | [
"recursion"
] | FStar.Krml.Endianness.offset_uint64_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> n: Prims.nat -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b = 8 * n /\ i < n)
(ensures
FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint64_of_be n b) i ==
FStar.Krml.Endianness.uint64_of_be (FStar.Seq.Base.slice b (8 * i) (8 * i +... | {
"end_col": 41,
"end_line": 380,
"start_col": 2,
"start_line": 373
} |
FStar.Pervasives.Lemma | val offset_uint32_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_le n b) i == uint32_of_le (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_le n b) i)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec offset_uint32_le (b: bytes) (n: nat) (i: nat):
Lemma
(requires (
S.length b = 4 * n /\
i < n))
(ensures (
S.index (seq_uint32_of_le n b) i == uint32_of_le (S.slice b (4 * i) (4 * i + 4))))
(decreases (
S.length b))
[ SMTPat (S.index (seq_uint32_of_le n b) i) ]
=
if S.... | val offset_uint32_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_le n b) i == uint32_of_le (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_le n b) i)]
let rec offset_uint32_le (b: bytes) (n i: na... | false | null | true | if S.length b = 0
then false_elim ()
else
let hd, tl = Seq.split b 4 in
if i = 0 then () else offset_uint32_le tl (n - 1) (i - 1) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Pervasives.false_elim",
"Prims.unit",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Krml.Endianness.offset_uint32_le",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val offset_uint32_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 4 * n /\ i < n))
(ensures (S.index (seq_uint32_of_le n b) i == uint32_of_le (S.slice b (4 * i) (4 * i + 4))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint32_of_le n b) i)] | [
"recursion"
] | FStar.Krml.Endianness.offset_uint32_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> n: Prims.nat -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b = 4 * n /\ i < n)
(ensures
FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint32_of_le n b) i ==
FStar.Krml.Endianness.uint32_of_le (FStar.Seq.Base.slice b (4 * i) (4 * i +... | {
"end_col": 41,
"end_line": 359,
"start_col": 2,
"start_line": 352
} |
FStar.Pervasives.Lemma | val be_of_seq_uint32_seq_uint32_of_be (n: nat) (s: S.seq U8.t)
: Lemma (requires (4 * n == S.length s))
(ensures ((be_of_seq_uint32 (seq_uint32_of_be n s)) `S.equal` s))
(decreases n)
[SMTPat (be_of_seq_uint32 (seq_uint32_of_be n s))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_of_seq_uint32_seq_uint32_of_be (n: nat) (s: S.seq U8.t) : Lemma
(requires (4 * n == S.length s))
(ensures (be_of_seq_uint32 (seq_uint32_of_be n s) `S.equal` s))
(decreases n)
[SMTPat (be_of_seq_uint32 (seq_uint32_of_be n s))]
= if n = 0
then ()
else begin
S.lemma_split s 4;
be_of_seq_uint... | val be_of_seq_uint32_seq_uint32_of_be (n: nat) (s: S.seq U8.t)
: Lemma (requires (4 * n == S.length s))
(ensures ((be_of_seq_uint32 (seq_uint32_of_be n s)) `S.equal` s))
(decreases n)
[SMTPat (be_of_seq_uint32 (seq_uint32_of_be n s))]
let rec be_of_seq_uint32_seq_uint32_of_be (n: nat) (s: S.seq U8... | false | null | true | if n = 0
then ()
else
(S.lemma_split s 4;
be_of_seq_uint32_seq_uint32_of_be (n - 1) (S.slice s 4 (S.length s));
let s' = seq_uint32_of_be n s in
let hd, tl = S.split s 4 in
assert (S.head s' == uint32_of_be hd);
tail_cons (uint32_of_be hd) (seq_uint32_of_be (n - 1) tl);
assert (S.tail s' == se... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"Prims.nat",
"FStar.Seq.Base.seq",
"FStar.UInt8.t",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"FStar.Krml.Endianness.n_to_be_be_to_n",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"FStar.Krml.Endiann... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val be_of_seq_uint32_seq_uint32_of_be (n: nat) (s: S.seq U8.t)
: Lemma (requires (4 * n == S.length s))
(ensures ((be_of_seq_uint32 (seq_uint32_of_be n s)) `S.equal` s))
(decreases n)
[SMTPat (be_of_seq_uint32 (seq_uint32_of_be n s))] | [
"recursion"
] | FStar.Krml.Endianness.be_of_seq_uint32_seq_uint32_of_be | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | n: Prims.nat -> s: FStar.Seq.Base.seq FStar.UInt8.t
-> FStar.Pervasives.Lemma (requires 4 * n == FStar.Seq.Base.length s)
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.be_of_seq_uint32 (FStar.Krml.Endianness.seq_uint32_of_be
n
s))
s)
(decreases ... | {
"end_col": 5,
"end_line": 548,
"start_col": 2,
"start_line": 534
} |
FStar.Pervasives.Lemma | val offset_uint64_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_le n b) i == uint64_of_le (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_le n b) i)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec offset_uint64_le (b: bytes) (n: nat) (i: nat):
Lemma
(requires (
S.length b = 8 * n /\
i < n))
(ensures (
S.index (seq_uint64_of_le n b) i == uint64_of_le (S.slice b (8 * i) (8 * i + 8))))
(decreases (
S.length b))
[ SMTPat (S.index (seq_uint64_of_le n b) i) ]
=
if S.... | val offset_uint64_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_le n b) i == uint64_of_le (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_le n b) i)]
let rec offset_uint64_le (b: bytes) (n i: na... | false | null | true | if S.length b = 0
then false_elim ()
else
let hd, tl = Seq.split b 8 in
if i = 0 then () else offset_uint64_le tl (n - 1) (i - 1) | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"FStar.Pervasives.false_elim",
"Prims.unit",
"Prims.bool",
"FStar.Seq.Base.seq",
"FStar.Krml.Endianness.offset_uint64_le",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val offset_uint64_le (b: bytes) (n i: nat)
: Lemma (requires (S.length b = 8 * n /\ i < n))
(ensures (S.index (seq_uint64_of_le n b) i == uint64_of_le (S.slice b (8 * i) (8 * i + 8))))
(decreases (S.length b))
[SMTPat (S.index (seq_uint64_of_le n b) i)] | [
"recursion"
] | FStar.Krml.Endianness.offset_uint64_le | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | b: FStar.Krml.Endianness.bytes -> n: Prims.nat -> i: Prims.nat
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b = 8 * n /\ i < n)
(ensures
FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint64_of_le n b) i ==
FStar.Krml.Endianness.uint64_of_le (FStar.Seq.Base.slice b (8 * i) (8 * i +... | {
"end_col": 41,
"end_line": 401,
"start_col": 2,
"start_line": 394
} |
FStar.Pervasives.Lemma | val le_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (le_of_seq_uint32 (S.append s1 s2))
(S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec le_of_seq_uint32_append (s1 s2: S.seq U32.t): Lemma
(ensures (
S.equal (le_of_seq_uint32 (S.append s1 s2))
(S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))))
(decreases (
S.length s1))
[ SMTPat (S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2)) ]
=
Classical.forall_intro_2 (tail_... | val le_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (le_of_seq_uint32 (S.append s1 s2))
(S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))]
let rec le_of_seq_ui... | false | null | true | Classical.forall_intro_2 (tail_cons #U32.t);
if S.length s1 = 0
then
(assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
())
else
(assert (S.equal (S.append s1 s2) (S.cons (S.head s1) (S.append (S.tail s1) s2)));
assert (S.equal (le_of_seq_uint32 (S.append s1 s2))
... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"FStar.UInt8.t",
"FStar.Krml.Endianness.le_of_seq_uint32",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Krml.En... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val le_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (le_of_seq_uint32 (S.append s1 s2))
(S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (le_of_seq_uint32 s1) (le_of_seq_uint32 s2))] | [
"recursion"
] | FStar.Krml.Endianness.le_of_seq_uint32_append | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s1: FStar.Seq.Base.seq FStar.UInt32.t -> s2: FStar.Seq.Base.seq FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.le_of_seq_uint32 (FStar.Seq.Base.append s1 s2))
(FStar.Seq.Base.append (FStar.Krml.Endianness.le_of_seq_uint32 s1)
(FStar.... | {
"end_col": 5,
"end_line": 467,
"start_col": 2,
"start_line": 457
} |
FStar.Pervasives.Lemma | val be_of_seq_uint64_append (s1 s2: S.seq U64.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint64 (S.append s1 s2))
(S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_of_seq_uint64_append (s1 s2: S.seq U64.t): Lemma
(ensures (
S.equal (be_of_seq_uint64 (S.append s1 s2))
(S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))))
(decreases (
S.length s1))
[ SMTPat (S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2)) ]
=
Classical.forall_intro_2 (tail_... | val be_of_seq_uint64_append (s1 s2: S.seq U64.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint64 (S.append s1 s2))
(S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))]
let rec be_of_seq_ui... | false | null | true | Classical.forall_intro_2 (tail_cons #U64.t);
if S.length s1 = 0
then
(assert (S.equal (be_of_seq_uint64 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
())
else
(assert (S.equal (S.append s1 s2) (S.cons (S.head s1) (S.append (S.tail s1) s2)));
assert (S.equal (be_of_seq_uint64 (S.append s1 s2))
... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt64.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"FStar.UInt8.t",
"FStar.Krml.Endianness.be_of_seq_uint64",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Krml.En... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val be_of_seq_uint64_append (s1 s2: S.seq U64.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint64 (S.append s1 s2))
(S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint64 s1) (be_of_seq_uint64 s2))] | [
"recursion"
] | FStar.Krml.Endianness.be_of_seq_uint64_append | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s1: FStar.Seq.Base.seq FStar.UInt64.t -> s2: FStar.Seq.Base.seq FStar.UInt64.t
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.be_of_seq_uint64 (FStar.Seq.Base.append s1 s2))
(FStar.Seq.Base.append (FStar.Krml.Endianness.be_of_seq_uint64 s1)
(FStar.... | {
"end_col": 5,
"end_line": 499,
"start_col": 2,
"start_line": 489
} |
FStar.Pervasives.Lemma | val be_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint32 (S.append s1 s2))
(S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "FStar.Math.Lemmas",
"short_module": "Math"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FSt... | false | let rec be_of_seq_uint32_append (s1 s2: S.seq U32.t): Lemma
(ensures (
S.equal (be_of_seq_uint32 (S.append s1 s2))
(S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))))
(decreases (
S.length s1))
[ SMTPat (S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2)) ]
=
Classical.forall_intro_2 (tail_... | val be_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint32 (S.append s1 s2))
(S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))]
let rec be_of_seq_ui... | false | null | true | Classical.forall_intro_2 (tail_cons #U32.t);
if S.length s1 = 0
then
(assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
())
else
(assert (S.equal (S.append s1 s2) (S.cons (S.head s1) (S.append (S.tail s1) s2)));
assert (S.equal (be_of_seq_uint32 (S.append s1 s2))
... | {
"checked_file": "FStar.Krml.Endianness.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fs... | [
"lemma",
""
] | [
"FStar.Seq.Base.seq",
"FStar.UInt32.t",
"Prims.op_Equality",
"Prims.int",
"FStar.Seq.Base.length",
"Prims.unit",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.append",
"FStar.UInt8.t",
"FStar.Krml.Endianness.be_of_seq_uint32",
"FStar.Seq.Base.empty",
"Prims.bool",
"FStar.Krml.En... | [] | module FStar.Krml.Endianness
open FStar.Mul
open FStar.HyperStack.All
module U8 = FStar.UInt8
module U32 = FStar.UInt32
module U64 = FStar.UInt64
module Math = FStar.Math.Lemmas
module S = FStar.Seq
(* Selectively imported from Hacl*'s FStar.Endianness.fst library, with several
name changes *)
inline_for_extraction... | false | false | FStar.Krml.Endianness.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 1,
"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... | null | val be_of_seq_uint32_append (s1 s2: S.seq U32.t)
: Lemma
(ensures
(S.equal (be_of_seq_uint32 (S.append s1 s2))
(S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))))
(decreases (S.length s1))
[SMTPat (S.append (be_of_seq_uint32 s1) (be_of_seq_uint32 s2))] | [
"recursion"
] | FStar.Krml.Endianness.be_of_seq_uint32_append | {
"file_name": "krmllib/FStar.Krml.Endianness.fst",
"git_rev": "a7be2a7c43eca637ceb57fe8f3ffd16fc6627ebd",
"git_url": "https://github.com/FStarLang/karamel.git",
"project_name": "karamel"
} | s1: FStar.Seq.Base.seq FStar.UInt32.t -> s2: FStar.Seq.Base.seq FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
FStar.Seq.Base.equal (FStar.Krml.Endianness.be_of_seq_uint32 (FStar.Seq.Base.append s1 s2))
(FStar.Seq.Base.append (FStar.Krml.Endianness.be_of_seq_uint32 s1)
(FStar.... | {
"end_col": 5,
"end_line": 435,
"start_col": 2,
"start_line": 425
} |
FStar.HyperStack.ST.Stack | val fmul_r2_normalize:
out:felem 2
-> p:precomp_r 2
-> Stack unit
(requires fun h ->
live h out /\ live h p /\
felem_fits h out (3, 3, 3, 3, 3) /\
load_precompute_r_post h p)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (2, 2, 2, 2, 2) /\
(let... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev"... | false | let fmul_r2_normalize out p =
let r = sub p 0ul 5ul in
let r2 = sub p 10ul 5ul in
let a0 = out.(0ul) in
let a1 = out.(1ul) in
let a2 = out.(2ul) in
let a3 = out.(3ul) in
let a4 = out.(4ul) in
let r10 = r.(0ul) in
let r11 = r.(1ul) in
let r12 = r.(2ul) in
let r13 = r.(3ul) in
let r14 = r.(4ul) ... | val fmul_r2_normalize:
out:felem 2
-> p:precomp_r 2
-> Stack unit
(requires fun h ->
live h out /\ live h p /\
felem_fits h out (3, 3, 3, 3, 3) /\
load_precompute_r_post h p)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (2, 2, 2, 2, 2) /\
(let... | true | null | false | let r = sub p 0ul 5ul in
let r2 = sub p 10ul 5ul in
let a0 = out.(0ul) in
let a1 = out.(1ul) in
let a2 = out.(2ul) in
let a3 = out.(3ul) in
let a4 = out.(4ul) in
let r10 = r.(0ul) in
let r11 = r.(1ul) in
let r12 = r.(2ul) in
let r13 = r.(3ul) in
let r14 = r.(4ul) in
let r20 = r2.(0ul) in
let r21 = r2.(1ul) in
let r22 =... | {
"checked_file": "Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked"... | [] | [
"Hacl.Impl.Poly1305.Field32xN.felem",
"Hacl.Impl.Poly1305.Field32xN.precomp_r",
"Hacl.Spec.Poly1305.Field32xN.uint64xN",
"Lib.Buffer.op_Array_Assignment",
"FStar.UInt32.__uint_to_t",
"Prims.unit",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32xN.fmul_r2_normalize5",
"FStar.Pervas... | [] | module Hacl.Impl.Poly1305.Field32xN_128
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
include Hacl.Spec.Poly1305.Field32xN
open Hacl.Spec.Poly1305.Field32xN.Lemmas
module Vec = Hacl.Spec.Poly1305.Vec
module ST = FStar.HyperStack.ST
open Hacl.Impl.Poly1305.Field32x... | false | false | Hacl.Impl.Poly1305.Field32xN_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val fmul_r2_normalize:
out:felem 2
-> p:precomp_r 2
-> Stack unit
(requires fun h ->
live h out /\ live h p /\
felem_fits h out (3, 3, 3, 3, 3) /\
load_precompute_r_post h p)
(ensures fun h0 _ h1 ->
modifies (loc out) h0 h1 /\
felem_fits h1 out (2, 2, 2, 2, 2) /\
(let... | [] | Hacl.Impl.Poly1305.Field32xN_128.fmul_r2_normalize | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Field32xN_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | out: Hacl.Impl.Poly1305.Field32xN.felem 2 -> p: Hacl.Impl.Poly1305.Field32xN.precomp_r 2
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 17,
"end_line": 101,
"start_col": 29,
"start_line": 73
} |
FStar.HyperStack.ST.Stack | val load_acc2:
acc:felem 2
-> b:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.lo... | [
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Poly1305.Vec",
"short_module": "Vec"
},
{
"abbrev"... | false | let load_acc2 acc b =
push_frame();
let e = create 5ul (zero 2) in
load_blocks e b;
let acc0 = acc.(0ul) in
let acc1 = acc.(1ul) in
let acc2 = acc.(2ul) in
let acc3 = acc.(3ul) in
let acc4 = acc.(4ul) in
let e0 = e.(0ul) in
let e1 = e.(1ul) in
let e2 = e.(2ul) in
let e3 = e.(3ul) in
let e4 = ... | val load_acc2:
acc:felem 2
-> b:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.lo... | true | null | false | push_frame ();
let e = create 5ul (zero 2) in
load_blocks e b;
let acc0 = acc.(0ul) in
let acc1 = acc.(1ul) in
let acc2 = acc.(2ul) in
let acc3 = acc.(3ul) in
let acc4 = acc.(4ul) in
let e0 = e.(0ul) in
let e1 = e.(1ul) in
let e2 = e.(2ul) in
let e3 = e.(3ul) in
let e4 = e.(4ul) in
let acc0, acc1, acc2, acc3, acc4 =
... | {
"checked_file": "Hacl.Impl.Poly1305.Field32xN_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Poly1305.Vec.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.Lemmas.fst.checked",
"Hacl.Spec.Poly1305.Field32xN.fst.checked"... | [] | [
"Hacl.Impl.Poly1305.Field32xN.felem",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.Poly1305.Field32xN.uint64xN",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Spec.Poly1305.Field32xN.felem5",
"Hacl.Spec.Poly1305.Field32... | [] | module Hacl.Impl.Poly1305.Field32xN_128
open FStar.HyperStack
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
include Hacl.Spec.Poly1305.Field32xN
open Hacl.Spec.Poly1305.Field32xN.Lemmas
module Vec = Hacl.Spec.Poly1305.Vec
module ST = FStar.HyperStack.ST
open Hacl.Impl.Poly1305.Field32x... | false | false | Hacl.Impl.Poly1305.Field32xN_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val load_acc2:
acc:felem 2
-> b:lbuffer uint8 32ul
-> Stack unit
(requires fun h ->
live h acc /\ live h b /\ disjoint acc b /\
felem_fits h acc (2, 2, 2, 2, 2))
(ensures fun h0 _ h1 ->
modifies (loc acc) h0 h1 /\
felem_fits h1 acc (3, 3, 3, 3, 3) /\
feval h1 acc == Vec.lo... | [] | Hacl.Impl.Poly1305.Field32xN_128.load_acc2 | {
"file_name": "code/poly1305/Hacl.Impl.Poly1305.Field32xN_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | acc: Hacl.Impl.Poly1305.Field32xN.felem 2 -> b: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 13,
"end_line": 57,
"start_col": 2,
"start_line": 35
} |
Prims.Tot | val ghost_ref (a:Type u#1) : Type u#0 | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_ref a = erased (ref a) | val ghost_ref (a:Type u#1) : Type u#0
let ghost_ref a = | false | null | false | erased (ref a) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"FStar.Ghost.erased",
"Steel.HigherReference.ref"
] | [] | (*
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... | false | true | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_ref (a:Type u#1) : Type u#0 | [] | Steel.HigherReference.ghost_ref | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> Type0 | {
"end_col": 32,
"end_line": 365,
"start_col": 18,
"start_line": 365
} |
Prims.Tot | val pts_to' (#a: Type u#1) (r: ref a) (p: perm) (v: erased a) : vprop | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let pts_to' (#a:Type u#1) (r:ref a) (p:perm) (v:erased a) : vprop = pts_to_raw r p v `star` pure (perm_ok p) | val pts_to' (#a: Type u#1) (r: ref a) (p: perm) (v: erased a) : vprop
let pts_to' (#a: Type u#1) (r: ref a) (p: perm) (v: erased a) : vprop = | false | null | false | (pts_to_raw r p v) `star` (pure (perm_ok p)) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Effect.Common.star",
"Steel.HigherReference.pts_to_raw",
"Steel.Effect.Common.pure",
"Steel.HigherReference.perm_ok",
"Steel.Effect.Common.vprop"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to' (#a: Type u#1) (r: ref a) (p: perm) (v: erased a) : vprop | [] | Steel.HigherReference.pts_to' | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: FStar.Ghost.erased a
-> Steel.Effect.Common.vprop | {
"end_col": 108,
"end_line": 40,
"start_col": 68,
"start_line": 40
} |
Prims.Tot | val null (#a:Type u#1) : ref a | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let null #a = Mem.null #(fractional a) #pcm_frac | val null (#a:Type u#1) : ref a
let null #a = | false | null | false | Mem.null #(fractional a) #pcm_frac | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.Memory.null",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.HigherReference.ref"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val null (#a:Type u#1) : ref a | [] | Steel.HigherReference.null | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | Steel.HigherReference.ref a | {
"end_col": 48,
"end_line": 32,
"start_col": 14,
"start_line": 32
} |
Prims.Tot | val pts_to_raw (#a: Type) (r: ref a) (p: perm) (v: erased a) : vprop | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let pts_to_raw (#a:Type) (r:ref a) (p:perm) (v:erased a) : vprop =
to_vprop (Mem.pts_to r (Some (Ghost.reveal v, p))) | val pts_to_raw (#a: Type) (r: ref a) (p: perm) (v: erased a) : vprop
let pts_to_raw (#a: Type) (r: ref a) (p: perm) (v: erased a) : vprop = | false | null | false | to_vprop (Mem.pts_to r (Some (Ghost.reveal v, p))) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.Effect.Common.to_vprop",
"Steel.Memory.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_raw (#a: Type) (r: ref a) (p: perm) (v: erased a) : vprop | [] | Steel.HigherReference.pts_to_raw | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: FStar.Ghost.erased a
-> Steel.Effect.Common.vprop | {
"end_col": 52,
"end_line": 38,
"start_col": 2,
"start_line": 38
} |
Prims.Tot | val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1 | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x | val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1
let ghost_pts_to_sl #a (r: ghost_ref a) (p: perm) (x: a) = | false | null | false | pts_to_sl (reveal r) p x | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ghost_ref",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.pts_to_sl",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"Steel.Memory.slprop"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1 | [] | Steel.HigherReference.ghost_pts_to_sl | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> p: Steel.FractionalPermission.perm -> x: a
-> Steel.Memory.slprop | {
"end_col": 80,
"end_line": 368,
"start_col": 56,
"start_line": 368
} |
Prims.Tot | val ref ([@@@unused] a:Type u#1) : Type u#0 | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ref a = Mem.ref (fractional a) pcm_frac | val ref ([@@@unused] a:Type u#1) : Type u#0
let ref a = | false | null | false | Mem.ref (fractional a) pcm_frac | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.Memory.ref",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac"
] | [] | (*
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... | false | true | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ref ([@@@unused] a:Type u#1) : Type u#0 | [] | Steel.HigherReference.ref | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> Type0 | {
"end_col": 43,
"end_line": 31,
"start_col": 12,
"start_line": 31
} |
Prims.Tot | val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1 | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let pts_to_sl #a r p v = hp_of (pts_to' r p v) | val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1
let pts_to_sl #a r p v = | false | null | false | hp_of (pts_to' r p v) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to'",
"FStar.Ghost.hide",
"Steel.Memory.slprop"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_sl (#a:Type u#1) (r:ref a) (p:perm) (v:a) : slprop u#1 | [] | Steel.HigherReference.pts_to_sl | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: a -> Steel.Memory.slprop | {
"end_col": 47,
"end_line": 41,
"start_col": 26,
"start_line": 41
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let cas_provides #t (r:ref t) (v:Ghost.erased t) (v_new:t) (b:bool) =
if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v | let cas_provides #t (r: ref t) (v: Ghost.erased t) (v_new: t) (b: bool) = | false | null | false | if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ref",
"FStar.Ghost.erased",
"Prims.bool",
"Steel.HigherReference.pts_to_sl",
"Steel.FractionalPermission.full_perm",
"FStar.Ghost.reveal",
"Steel.Memory.slprop"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val cas_provides : r: Steel.HigherReference.ref t -> v: FStar.Ghost.erased t -> v_new: t -> b: Prims.bool
-> Steel.Memory.slprop | [] | Steel.HigherReference.cas_provides | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref t -> v: FStar.Ghost.erased t -> v_new: t -> b: Prims.bool
-> Steel.Memory.slprop | {
"end_col": 70,
"end_line": 284,
"start_col": 4,
"start_line": 284
} | |
FStar.Pervasives.Lemma | val abcd_acbd (a b c d: slprop)
: Lemma
(let open Mem in ((a `star` b) `star` (c `star` d)) `equiv` ((a `star` c) `star` (b `star` d))) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let abcd_acbd (a b c d:slprop)
: Lemma (Mem.(((a `star` b) `star` (c `star` d)) `equiv`
((a `star` c) `star` (b `star` d))))
= let open Steel.Memory in
calc (equiv) {
((a `star` b) `star` (c `star` d));
(equiv) { star_associative a b (c `star` d) }
((a `star` (b `star` (c `star` d))));
... | val abcd_acbd (a b c d: slprop)
: Lemma
(let open Mem in ((a `star` b) `star` (c `star` d)) `equiv` ((a `star` c) `star` (b `star` d)))
let abcd_acbd (a b c d: slprop)
: Lemma
(let open Mem in ((a `star` b) `star` (c `star` d)) `equiv` ((a `star` c) `star` (b `star` d))) = | false | null | true | let open Steel.Memory in
calc (equiv) {
((a `star` b) `star` (c `star` d));
(equiv) { star_associative a b (c `star` d) }
((a `star` (b `star` (c `star` d))));
(equiv) { (star_associative b c d;
star_congruence a (b `star` (c `star` d)) a ((b `star` c) `star` d)) }
(a `star` ((b `star` c) `star` d));
(e... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.Memory.slprop",
"FStar.Calc.calc_finish",
"Steel.Memory.equiv",
"Steel.Memory.star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Steel.Memory.star_associative",
"Prims.squash",
"Steel.Me... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val abcd_acbd (a b c d: slprop)
: Lemma
(let open Mem in ((a `star` b) `star` (c `star` d)) `equiv` ((a `star` c) `star` (b `star` d))) | [] | Steel.HigherReference.abcd_acbd | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Steel.Memory.slprop -> b: Steel.Memory.slprop -> c: Steel.Memory.slprop -> d: Steel.Memory.slprop
-> FStar.Pervasives.Lemma
(ensures
Steel.Memory.equiv (Steel.Memory.star (Steel.Memory.star a b) (Steel.Memory.star c d))
(Steel.Memory.star (Steel.Memory.star a c) (Steel.Memory.star b d))) | {
"end_col": 4,
"end_line": 66,
"start_col": 4,
"start_line": 46
} |
FStar.Pervasives.Lemma | val pts_to_not_null (#a:Type u#1)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let pts_to_not_null (#a:Type u#1)
(r:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl r p v) m)
(ensures r =!= null)
= Mem.affine_star (hp_of (pts_to_raw r p v)) (Mem.pure (perm_ok p)) m;
Mem.pts_to_not_nu... | val pts_to_not_null (#a:Type u#1)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null)
let pts_to_not_null (#a: Type u#1) (r: ref a) (p: perm) (v: a) (m: mem)
: Lemma (requires ... | false | null | true | Mem.affine_star (hp_of (pts_to_raw r p v)) (Mem.pure (perm_ok p)) m;
Mem.pts_to_not_null r (Some (Ghost.reveal v, p)) m | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Memory.mem",
"Steel.Memory.pts_to_not_null",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
"F... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_not_null (#a:Type u#1)
(x:ref a)
(p:perm)
(v:a)
(m:mem)
: Lemma (requires interp (pts_to_sl x p v) m)
(ensures x =!= null) | [] | Steel.HigherReference.pts_to_not_null | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm -> v: a -> m: Steel.Memory.mem
-> FStar.Pervasives.Lemma (requires Steel.Memory.interp (Steel.HigherReference.pts_to_sl x p v) m)
(ensures ~(x == Steel.HigherReference.null)) | {
"end_col": 54,
"end_line": 97,
"start_col": 4,
"start_line": 96
} |
FStar.Pervasives.Lemma | val pts_to_framon (#a: Type) (r: ref a) (p: perm) : Lemma (is_frame_monotonic (pts_to_sl r p)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let pts_to_framon (#a:Type) (r:ref a) (p:perm) : Lemma (is_frame_monotonic (pts_to_sl r p)) =
pts_to_witinv r p | val pts_to_framon (#a: Type) (r: ref a) (p: perm) : Lemma (is_frame_monotonic (pts_to_sl r p))
let pts_to_framon (#a: Type) (r: ref a) (p: perm) : Lemma (is_frame_monotonic (pts_to_sl r p)) = | false | null | true | pts_to_witinv r p | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.pts_to_witinv",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Steel.Memory.is_frame_monotonic",
"Steel.HigherReference.pts_to_sl",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_framon (#a: Type) (r: ref a) (p: perm) : Lemma (is_frame_monotonic (pts_to_sl r p)) | [] | Steel.HigherReference.pts_to_framon | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm
-> FStar.Pervasives.Lemma
(ensures Steel.Memory.is_frame_monotonic (Steel.HigherReference.pts_to_sl r p)) | {
"end_col": 19,
"end_line": 114,
"start_col": 2,
"start_line": 114
} |
Prims.Tot | val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null}) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r | val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null})
let is_null #a r = | false | null | false | Mem.is_null #(fractional a) #pcm_frac r | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Steel.HigherReference.ref",
"Steel.Memory.is_null",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2",
"Steel.HigherReference.null"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val is_null (#a:Type u#1) (r:ref a) : (b:bool{b <==> r == null}) | [] | Steel.HigherReference.is_null | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> b: Prims.bool{b <==> r == Steel.HigherReference.null} | {
"end_col": 58,
"end_line": 33,
"start_col": 19,
"start_line": 33
} |
FStar.Pervasives.Lemma | val ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
let aux (x y : erased a) (m:mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
[SMTPat ()]
=
Mem.pts_to_... | val ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p))
let ghost_pts_to_witinv (#a: Type) (r: ghost_ref a) (p: perm)
: Lemma (is_witness_invariant (ghost_pts_to_sl r p)) = | false | null | true | let aux (x y: erased a) (m: mem)
: Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
(ensures (x == y))
[SMTPat ()] =
Mem.pts_to_join (Ghost.reveal r) (Some (Ghost.reveal x, p)) (Some (Ghost.reveal y, p)) m
in
assert (forall x y m.
interp (ghost_pts_to_sl r ... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.HigherReference.ghost_ref",
"Steel.FractionalPermission.perm",
"Prims._assert",
"Steel.Memory.is_witness_invariant",
"Steel.HigherReference.ghost_pts_to_sl",
"Prims.unit",
"Prims.l_Forall",
"Steel.Memory.mem",
"Prims.l_imp",
"Prims.l_and",
"Steel.Memory.interp",
"Prims.eq2",
"FStar.Gh... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) | [] | Steel.HigherReference.ghost_pts_to_witinv | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> p: Steel.FractionalPermission.perm
-> FStar.Pervasives.Lemma
(ensures Steel.Memory.is_witness_invariant (Steel.HigherReference.ghost_pts_to_sl r p)) | {
"end_col": 53,
"end_line": 384,
"start_col": 113,
"start_line": 375
} |
FStar.Pervasives.Lemma | val cas_action_helper (p q r s: slprop) (m: mem)
: Lemma (requires interp Mem.(((p `star` q) `star` r) `star` s) m)
(ensures interp Mem.((p `star` q) `star` s) m) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let cas_action_helper (p q r s:slprop) (m:mem)
: Lemma
(requires interp Mem.(p `star` q `star` r `star` s) m)
(ensures interp Mem.(p `star` q `star` s) m)
= let open Steel.Memory in
calc (equiv) {
r `star` s;
(equiv) { star_commutative r s }
s `star` r;
};
calc (equiv) {... | val cas_action_helper (p q r s: slprop) (m: mem)
: Lemma (requires interp Mem.(((p `star` q) `star` r) `star` s) m)
(ensures interp Mem.((p `star` q) `star` s) m)
let cas_action_helper (p q r s: slprop) (m: mem)
: Lemma (requires interp Mem.(((p `star` q) `star` r) `star` s) m)
(ensures interp Mem.(... | false | null | true | let open Steel.Memory in
calc (equiv) {
r `star` s;
(equiv) { star_commutative r s }
s `star` r;
};
calc (equiv) {
((p `star` q) `star` r) `star` s;
(equiv) { Mem.star_associative (p `star` q) r s }
(p `star` q) `star` (r `star` s);
(equiv) { equiv_ext_right (p `star` q) (r `star` s) (s `star` r) }
(p `... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.Memory.slprop",
"Steel.Memory.mem",
"Steel.Memory.affine_star",
"Steel.Memory.star",
"Prims.unit",
"Prims._assert",
"Steel.Memory.interp",
"FStar.Calc.calc_finish",
"Steel.Memory.equiv",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_i... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val cas_action_helper (p q r s: slprop) (m: mem)
: Lemma (requires interp Mem.(((p `star` q) `star` r) `star` s) m)
(ensures interp Mem.((p `star` q) `star` s) m) | [] | Steel.HigherReference.cas_action_helper | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
p: Steel.Memory.slprop ->
q: Steel.Memory.slprop ->
r: Steel.Memory.slprop ->
s: Steel.Memory.slprop ->
m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Memory.star (Steel.Memory.star (Steel.Memory.star p q) r) s) m)
(ensures Steel.Memory.inte... | {
"end_col": 41,
"end_line": 323,
"start_col": 4,
"start_line": 305
} |
FStar.Pervasives.Lemma | val pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
= let open Steel.Memory in
abcd_acbd (hp_of (pts_to_raw r p0 v0))
... | val pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1)
let pts_to_ref_injective (#a: Type u#1) (r: ref a) (p0 p1: perm) (v0 v1: a) (m: mem)
... | false | null | true | let open Steel.Memory in
abcd_acbd (hp_of (pts_to_raw r p0 v0))
(pure (perm_ok p0))
(hp_of (pts_to_raw r p1 v1))
(pure (perm_ok p1));
Mem.affine_star ((hp_of (pts_to_raw r p0 v0)) `star` (hp_of (pts_to_raw r p1 v1)))
((pure (perm_ok p0)) `star` (pure (perm_ok p1)))
m;
Mem.pts_to_compatible r (Some (Ghost.reve... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"Steel.Memory.mem",
"Steel.Memory.pts_to_compatible",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_ref_injective
(#a: Type u#1)
(r: ref a)
(p0 p1:perm)
(v0 v1:a)
(m:mem)
: Lemma
(requires
interp (pts_to_sl r p0 v0 `Mem.star` pts_to_sl r p1 v1) m)
(ensures v0 == v1) | [] | Steel.HigherReference.pts_to_ref_injective | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
r: Steel.HigherReference.ref a ->
p0: Steel.FractionalPermission.perm ->
p1: Steel.FractionalPermission.perm ->
v0: a ->
v1: a ->
m: Steel.Memory.mem
-> FStar.Pervasives.Lemma
(requires
Steel.Memory.interp (Steel.Memory.star (Steel.HigherReference.pts_to_sl r p0 v0)
... | {
"end_col": 31,
"end_line": 87,
"start_col": 6,
"start_line": 78
} |
FStar.Pervasives.Lemma | val pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) =
let aux (x y : erased a) (m:mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m))
(ensures (x == y))
=
Mem.pts_to_join r (Some (Ghost.reveal x, p)) (Some (Ghost.reveal ... | val pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p))
let pts_to_witinv (#a: Type) (r: ref a) (p: perm) : Lemma (is_witness_invariant (pts_to_sl r p)) = | false | null | true | let aux (x y: erased a) (m: mem)
: Lemma (requires (interp (pts_to_sl r p x) m /\ interp (pts_to_sl r p y) m)) (ensures (x == y))
=
Mem.pts_to_join r (Some (Ghost.reveal x, p)) (Some (Ghost.reveal y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y)) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.HigherReference.ref",
"Steel.FractionalPermission.perm",
"FStar.Classical.forall_intro_3",
"FStar.Ghost.erased",
"Steel.Memory.mem",
"Prims.l_imp",
"Prims.l_and",
"Steel.Memory.interp",
"Steel.HigherReference.pts_to_sl",
"FStar.Ghost.reveal",
"Prims.eq2",
"FStar.Classical.move_requires"... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pts_to_witinv (#a:Type) (r:ref a) (p:perm) : Lemma (is_witness_invariant (pts_to_sl r p)) | [] | Steel.HigherReference.pts_to_witinv | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> p: Steel.FractionalPermission.perm
-> FStar.Pervasives.Lemma
(ensures Steel.Memory.is_witness_invariant (Steel.HigherReference.pts_to_sl r p)) | {
"end_col": 73,
"end_line": 106,
"start_col": 95,
"start_line": 99
} |
Steel.Effect.Atomic.SteelGhostT | val ghost_share (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
: SteelGhostT unit u
(ghost_pts_to r p x)
(fun _ -> ghost_pts_to r (half_perm p) x `star`
ghost_pts_to r (half_perm p) x) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_share r = share (reveal r) | val ghost_share (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
: SteelGhostT unit u
(ghost_pts_to r p x)
(fun _ -> ghost_pts_to r (half_perm p) x `star`
ghost_pts_to r (half_perm p) x)
let ghost_share r = | true | null | false | share (reveal r) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ghost_ref",
"Steel.HigherReference.share",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"Prims.unit"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_share (#a:Type) (#u:_)
(#p:perm)
(#x:erased a)
(r:ghost_ref a)
: SteelGhostT unit u
(ghost_pts_to r p x)
(fun _ -> ghost_pts_to r (half_perm p) x `star`
ghost_pts_to r (half_perm p) x) | [] | Steel.HigherReference.ghost_share | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 36,
"end_line": 415,
"start_col": 20,
"start_line": 415
} |
FStar.Pervasives.Lemma | val equiv_ext_right (p q r: slprop)
: Lemma (requires q `Mem.equiv` r) (ensures Mem.((p `star` q) `equiv` (p `star` r))) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let equiv_ext_right (p q r:slprop)
: Lemma
(requires q `Mem.equiv` r)
(ensures Mem.((p `star` q) `equiv` (p `star` r)))
= let open Steel.Memory in
calc (equiv) {
p `star` q;
(equiv) { star_commutative p q }
q `star` p;
(equiv) { equiv_extensional_on_star q r p }
r... | val equiv_ext_right (p q r: slprop)
: Lemma (requires q `Mem.equiv` r) (ensures Mem.((p `star` q) `equiv` (p `star` r)))
let equiv_ext_right (p q r: slprop)
: Lemma (requires q `Mem.equiv` r) (ensures Mem.((p `star` q) `equiv` (p `star` r))) = | false | null | true | let open Steel.Memory in
calc (equiv) {
p `star` q;
(equiv) { star_commutative p q }
q `star` p;
(equiv) { equiv_extensional_on_star q r p }
r `star` p;
(equiv) { star_commutative p r }
p `star` r;
} | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"lemma"
] | [
"Steel.Memory.slprop",
"FStar.Calc.calc_finish",
"Steel.Memory.equiv",
"Steel.Memory.star",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Steel.Memory.star_commutative",
"Prims.squash",
"Steel.Me... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val equiv_ext_right (p q r: slprop)
: Lemma (requires q `Mem.equiv` r) (ensures Mem.((p `star` q) `equiv` (p `star` r))) | [] | Steel.HigherReference.equiv_ext_right | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.Memory.slprop -> q: Steel.Memory.slprop -> r: Steel.Memory.slprop
-> FStar.Pervasives.Lemma (requires Steel.Memory.equiv q r)
(ensures Steel.Memory.equiv (Steel.Memory.star p q) (Steel.Memory.star p r)) | {
"end_col": 5,
"end_line": 299,
"start_col": 4,
"start_line": 290
} |
Steel.Effect.Atomic.SteelGhost | val ghost_gather (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> True)
(ensures fun _ _ _ -... | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_gather r = gather (reveal r) | val ghost_gather (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> True)
(ensures fun _ _ _ -... | true | null | false | gather (reveal r) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ghost_ref",
"Steel.HigherReference.gather",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"Prims.unit"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_gather (#a:Type) (#u:_)
(#p0 #p1:perm)
(#x0 #x1:erased a)
(r:ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p0 x0 `star`
ghost_pts_to r p1 x1)
(fun _ -> ghost_pts_to r (sum_perm p0 p1) x0)
(requires fun _ -> True)
(ensures fun _ _ _ -... | [] | Steel.HigherReference.ghost_gather | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 38,
"end_line": 416,
"start_col": 21,
"start_line": 416
} |
Steel.Effect.Atomic.SteelGhost | val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_pts_to_injective_eq #_ #_ #p0 #p1 r v0 v1 =
higher_ref_pts_to_injective_eq #_ #_ #p0 #p1 #v0 #v1 (reveal r) | val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
let ghost_pts_to_injectiv... | true | null | false | higher_ref_pts_to_injective_eq #_ #_ #p0 #p1 #v0 #v1 (reveal r) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.ghost_ref",
"FStar.Ghost.erased",
"Steel.HigherReference.higher_ref_pts_to_injective_eq",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"Prims.unit"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Ghost.erased a)
: SteelGhost unit u
(ghost_pts_to r p v0 `star` ghost_pts_to r q v1)
(fun _ -> ghost_pts_to r p v0 `star` ghost_pts_to r q v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | [] | Steel.HigherReference.ghost_pts_to_injective_eq | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 65,
"end_line": 419,
"start_col": 2,
"start_line": 419
} |
Steel.Effect.Atomic.SteelGhostT | val ghost_alloc (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r | val ghost_alloc (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x)
let ghost_alloc x = | true | null | false | let r = ghost_alloc_aux (reveal x) in
hide r | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"Steel.HigherReference.ref",
"Steel.HigherReference.ghost_ref",
"Steel.HigherReference.ghost_alloc_aux",
"FStar.Ghost.reveal"
] | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_alloc (#a:Type) (#u:_) (x:erased a)
: SteelGhostT (ghost_ref a) u
emp
(fun r -> ghost_pts_to r full_perm x) | [] | Steel.HigherReference.ghost_alloc | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: FStar.Ghost.erased a -> Steel.Effect.Atomic.SteelGhostT (Steel.HigherReference.ghost_ref a) | {
"end_col": 8,
"end_line": 403,
"start_col": 19,
"start_line": 401
} |
Steel.Effect.Atomic.SteelGhostT | val ghost_write (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_write r x =
ghost_write_aux (reveal r) (reveal x);
rewrite_slprop
(pts_to (reveal r) full_perm (hide (reveal x)))
(ghost_pts_to r full_perm x)
(fun _ -> ()) | val ghost_write (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x)
let ghost_write r x = | true | null | false | ghost_write_aux (reveal r) (reveal x);
rewrite_slprop (pts_to (reveal r) full_perm (hide (reveal x)))
(ghost_pts_to r full_perm x)
(fun _ -> ()) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.HigherReference.ghost_ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"Steel.FractionalPermission.full_perm",
"Steel.HigherReference.ghost_pts_to",
"Steel.Memory.mem",... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_write (#a:Type) (#u:_) (#v:erased a) (r:ghost_ref a) (x:erased a)
: SteelGhostT unit u
(ghost_pts_to r full_perm v)
(fun _ -> ghost_pts_to r full_perm x) | [] | Steel.HigherReference.ghost_write | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> x: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 17,
"end_line": 469,
"start_col": 2,
"start_line": 465
} |
Steel.Effect.Atomic.SteelGhost | val higher_ref_pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(e... | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let higher_ref_pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r =
extract_info_raw (pts_to r p0 v0 `star` pts_to r p1 v1) (v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ()) | val higher_ref_pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(e... | true | null | false | extract_info_raw ((pts_to r p0 v0) `star` (pts_to r p1 v1))
(v0 == v1)
(fun m -> pts_to_ref_injective r p0 p1 v0 v1 m);
rewrite_slprop (pts_to r p1 v1) (pts_to r p1 v0) (fun _ -> ()) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Effect.Atomic.extract_info_raw",
"Steel.Effect.Common.... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val higher_ref_pts_to_injective_eq
(#a: Type)
(#opened:inames)
(#p0 #p1:perm)
(#v0 #v1: erased a)
(r: ref a)
: SteelGhost unit opened
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
(requires fun _ -> True)
(e... | [] | Steel.HigherReference.higher_ref_pts_to_injective_eq | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 64,
"end_line": 111,
"start_col": 2,
"start_line": 109
} |
Steel.Effect.Atomic.SteelGhost | val intro_pts_to (p: perm) (#a #uses: _) (#v: erased a) (r: ref a)
: SteelGhost unit
uses
(pts_to_raw r p v)
(fun _ -> pts_to r p v)
(requires fun _ -> perm_ok p)
(ensures fun _ _ _ -> True) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let intro_pts_to (p:perm) #a #uses (#v:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to_raw r p v)
(fun _ -> pts_to r p v)
(requires fun _ -> perm_ok p)
(ensures fun _ _ _ -> True)
= intro_pure (perm_ok p);
rewrite_slprop (pts_to' r p v) (pts_to ... | val intro_pts_to (p: perm) (#a #uses: _) (#v: erased a) (r: ref a)
: SteelGhost unit
uses
(pts_to_raw r p v)
(fun _ -> pts_to r p v)
(requires fun _ -> perm_ok p)
(ensures fun _ _ _ -> True)
let intro_pts_to (p: perm) #a #uses (#v: erased a) (r: ref a)
: SteelGhost unit
uses
... | true | null | false | intro_pure (perm_ok p);
rewrite_slprop (pts_to' r p v) (pts_to r p v) (fun _ -> ()) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.FractionalPermission.perm",
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to'",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Effect.Atomic.intro_p... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val intro_pts_to (p: perm) (#a #uses: _) (#v: erased a) (r: ref a)
: SteelGhost unit
uses
(pts_to_raw r p v)
(fun _ -> pts_to r p v)
(requires fun _ -> perm_ok p)
(ensures fun _ _ _ -> True) | [] | Steel.HigherReference.intro_pts_to | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | p: Steel.FractionalPermission.perm -> r: Steel.HigherReference.ref a
-> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 63,
"end_line": 123,
"start_col": 4,
"start_line": 122
} |
Prims.Tot | val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl ... | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:Ghost.erased t)
(v_old:t)
(v_new:t)
(fr:slprop)
: MstTot
(b:bool{b <==> (Ghost.reveal v == v_old)})
uses
... | val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl ... | false | null | false | let m0:full_mem = NMSTTotal.get () in
let fv = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
let fv' = Some (v_new, full_perm) in
assert (interp Mem.(((pts_to_sl r full_perm v) `star` fr) `star` (locks_invariant uses m0)) m0);
assert (interp Mem.((((pts_to r fv) `star` (pure (perm_ok full_perm))) `star` fr)
... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [
"total"
] | [
"Prims.bool",
"Prims.l_iff",
"Prims.b2t",
"Prims.eq2",
"Steel.Memory.inames",
"Steel.HigherReference.ref",
"FStar.Ghost.erased",
"Steel.Memory.slprop",
"Steel.FractionalPermission.perm",
"FStar.Ghost.reveal",
"Prims.unit",
"Steel.Memory.frame",
"Steel.Memory.pts_to",
"Steel.PCMFrac.fractio... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl ... | [] | Steel.HigherReference.cas_action | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
eq: (x: t -> y: t -> b: Prims.bool{b <==> x == y}) ->
r: Steel.HigherReference.ref t ->
v: FStar.Ghost.erased t ->
v_old: t ->
v_new: t
-> Steel.Memory.action_except (b: Prims.bool{b <==> FStar.Ghost.reveal v == v_old})
uses
(Steel.HigherReference.pts_to_sl r Steel.FractionalPermissio... | {
"end_col": 6,
"end_line": 361,
"start_col": 4,
"start_line": 340
} |
Steel.Effect.Atomic.SteelGhost | val ghost_pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p v)
(fun _ -> ghost_pts_to r p v)
(fun _ -> True)
(fun _ _ _ -> p `lesser_equal_perm` full_perm) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let ghost_pts_to_perm #a #_ #p #v r =
let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop
(ghost_pts_to r p v)
(RP.pts_to r v_old `star` pure (perm_ok p))
(fun _ -> ());
elim_pure (perm_ok p);
intro_pure (perm_ok p);
rewrite_slprop
(RP.pt... | val ghost_pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p v)
(fun _ -> ghost_pts_to r p v)
(fun _ -> True)
(fun _ _ _ -> p `lesser_equal_perm` full_perm)
let ghost_pts_to_perm #a #_ #p #v r = | true | null | false | let v_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (ghost_pts_to r p v) ((RP.pts_to r v_old) `star` (pure (perm_ok p))) (fun _ -> ());
elim_pure (perm_ok p);
intro_pure (perm_ok p);
rewrite_slprop ((RP.pts_to r v_old) `star` (pure (perm_ok p))) (ghost_pts_to r p v) (fun _ -> ()) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.ghost_ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.Effect.Common.star",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Ghost.reveal",
"Steel.HigherReference.ref",
"St... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val ghost_pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ghost_ref a)
: SteelGhost unit u
(ghost_pts_to r p v)
(fun _ -> ghost_pts_to r p v)
(fun _ -> True)
(fun _ _ _ -> p `lesser_equal_perm` full_perm) | [] | Steel.HigherReference.ghost_pts_to_perm | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ghost_ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 19,
"end_line": 432,
"start_col": 37,
"start_line": 421
} |
Steel.Effect.Atomic.SteelAtomicT | val atomic_write (#opened:_) (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelAtomicT unit opened (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let atomic_write #opened #a #v r x
= let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
let v_new : fractional a = Some (x, full_perm) in
rewrite_slprop (pts_to r full_perm v) (RP.pts_to r v_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm... | val atomic_write (#opened:_) (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelAtomicT unit opened (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
let atomic_write #opened #a #v r x = | true | null | false | let v_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
let v_new:fractional a = Some (x, full_perm) in
rewrite_slprop (pts_to r full_perm v)
((RP.pts_to r v_old) `star` (pure (perm_ok full_perm)))
(fun _ -> ());
elim_pure (perm_ok full_perm);
RP.atomic_write r v_old v_new;
rewrite_slprop... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.HigherReference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Memory.mem",
"Steel.Me... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val atomic_write (#opened:_) (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelAtomicT unit opened (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | [] | Steel.HigherReference.atomic_write | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> x: a -> Steel.Effect.Atomic.SteelAtomicT Prims.unit | {
"end_col": 84,
"end_line": 203,
"start_col": 3,
"start_line": 194
} |
Steel.Effect.Steel | val alloc (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r)) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let alloc #a x =
let v = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
let r = RP.alloc v in
rewrite_slprop (RP.pts_to r v) (pts_to r full_perm x)
(fun m ->
emp_unit (hp_of (pts_to_raw r full_perm x));
pure_star_interp (hp_of (pts_to_ra... | val alloc (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r))
let alloc #a x = | true | null | false | let v = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
let r = RP.alloc v in
rewrite_slprop (RP.pts_to r v)
(pts_to r full_perm x)
(fun m ->
emp_unit (hp_of (pts_to_raw r full_perm x));
pure_star_interp (hp_of (pts_to_raw r full_perm x)) (perm_ok ... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Effect.Atomic.return",
"Steel.HigherReference.ref",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.HigherReference.pts_to",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.extract_info_raw",
"P... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val alloc (#a:Type) (x:a)
: Steel (ref a) emp (fun r -> pts_to r full_perm x)
(requires fun _ -> True)
(ensures fun _ r _ -> not (is_null r)) | [] | Steel.HigherReference.alloc | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | x: a -> Steel.Effect.Steel (Steel.HigherReference.ref a) | {
"end_col": 11,
"end_line": 137,
"start_col": 16,
"start_line": 125
} |
Steel.Effect.Atomic.SteelGhostT | val share_atomic_raw (#a #uses: _) (#p: perm) (r: ref a {perm_ok p}) (v0: erased a)
: SteelGhostT unit
uses
(pts_to_raw r p v0)
(fun _ -> (pts_to_raw r (half_perm p) v0) `star` (pts_to_raw r (half_perm p) v0)) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let share_atomic_raw #a #uses (#p:perm) (r:ref a{perm_ok p}) (v0:erased a)
: SteelGhostT unit uses
(pts_to_raw r p v0)
(fun _ -> pts_to_raw r (half_perm p) v0 `star` pts_to_raw r (half_perm p) v0)
= rewrite_slprop
(pts_to_raw r p v0)
(RP.pts_to r _)
(fun _ -> ());
... | val share_atomic_raw (#a #uses: _) (#p: perm) (r: ref a {perm_ok p}) (v0: erased a)
: SteelGhostT unit
uses
(pts_to_raw r p v0)
(fun _ -> (pts_to_raw r (half_perm p) v0) `star` (pts_to_raw r (half_perm p) v0))
let share_atomic_raw #a #uses (#p: perm) (r: ref a {perm_ok p}) (v0: erased a)
: Ste... | true | null | false | rewrite_slprop (pts_to_raw r p v0) (RP.pts_to r _) (fun _ -> ());
RP.split r
(Some (Ghost.reveal v0, p))
(Some (Ghost.reveal v0, half_perm p))
(Some (Ghost.reveal v0, half_perm p));
rewrite_slprop (RP.pts_to r _) (pts_to_raw r (half_perm p) v0) (fun _ -> ());
rewrite_slprop (RP.pts_to r _) (pts_to_raw r (half_per... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.ref",
"Steel.HigherReference.perm_ok",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Pervasives.Native.Some",
"... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val share_atomic_raw (#a #uses: _) (#p: perm) (r: ref a {perm_ok p}) (v0: erased a)
: SteelGhostT unit
uses
(pts_to_raw r p v0)
(fun _ -> (pts_to_raw r (half_perm p) v0) `star` (pts_to_raw r (half_perm p) v0)) | [] | Steel.HigherReference.share_atomic_raw | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a {Steel.HigherReference.perm_ok p} -> v0: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 19,
"end_line": 232,
"start_col": 4,
"start_line": 220
} |
Steel.Effect.SteelT | val free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp)
= let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
rewrite_slprop
(pts_to r full_perm v)
(RP.pts_to r v_old `star` pure (perm_ok full_perm))
(fun _ -> ());
eli... | val free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp)
let free (#a: Type) (#v: erased a) (r: ref a) : SteelT unit (pts_to r full_perm v) (fun _ -> emp) = | true | null | false | let v_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
rewrite_slprop (pts_to r full_perm v)
((RP.pts_to r v_old) `star` (pure (perm_ok full_perm)))
(fun _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac))) | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.drop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.PCM.__proj__Mkpcm'__item__one",
"FStar.PCM.__pr... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val free (#a:Type) (#v:erased a) (r:ref a)
: SteelT unit (pts_to r full_perm v) (fun _ -> emp) | [] | Steel.HigherReference.free | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.SteelT Prims.unit | {
"end_col": 56,
"end_line": 214,
"start_col": 3,
"start_line": 207
} |
Steel.Effect.SteelT | val write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
= let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
let v_new : fractional a = Some (x, full_perm) in
rewrite_slprop (pts_to r full_perm v) (RP.pts_to r v... | val write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x)
let write (#a: Type) (#v: erased a) (r: ref a) (x: a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) = | true | null | false | let v_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, full_perm)) in
let v_new:fractional a = Some (x, full_perm) in
rewrite_slprop (pts_to r full_perm v)
((RP.pts_to r v_old) `star` (pure (perm_ok full_perm)))
(fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pt... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.HigherReference.pts_to",
"Steel.Fract... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val write (#a:Type) (#v:erased a) (r:ref a) (x:a)
: SteelT unit (pts_to r full_perm v) (fun _ -> pts_to r full_perm x) | [] | Steel.HigherReference.write | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> x: a -> Steel.Effect.SteelT Prims.unit | {
"end_col": 84,
"end_line": 191,
"start_col": 3,
"start_line": 182
} |
Steel.Effect.Atomic.SteelGhostT | val share (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let share (#a:Type) #uses (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
= let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop
(pts_to r p v)
... | val share (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
let share (#a: Type) #uses (#p: perm) (#v: erased a) (r: ref a)
: SteelGhostT unit
uses
(pts_to r p v)
(fun _ -> (pts... | true | null | false | let v_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (pts_to r p v) (pts_to' r p v) (fun _ -> ());
elim_pure (perm_ok p);
share_atomic_raw r v;
intro_pts_to (half_perm p) r;
intro_pts_to (half_perm p) r | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.HigherReference.intro_pts_to",
"Steel.FractionalPermission.half_perm",
"Prims.unit",
"Steel.HigherReference.share_atomic_raw",
"Steel.Effect.Atomic.elim_pure",
"Steel.HigherReference... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val share (#a:Type) (#uses:_) (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v)
(fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v) | [] | Steel.HigherReference.share | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.Atomic.SteelGhostT Prims.unit | {
"end_col": 32,
"end_line": 246,
"start_col": 3,
"start_line": 238
} |
Steel.Effect.Atomic.SteelGhost | val gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r (sum_perm p0 p1) v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
= let v0_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v0, p0)) in
let v1_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v1, p1)) in
rewrite_slprop
(pts_to r p0 v0)
(pts_to_raw r p0 v0 `s... | val gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r (sum_perm p0 p1) v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1)
let gather (#a: Type) (#uses: _) (#p0 #p1: perm) (#v0 #v1: er... | true | null | false | let v0_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v0, p0)) in
let v1_old:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v1, p1)) in
rewrite_slprop (pts_to r p0 v0) ((pts_to_raw r p0 v0) `star` (pure (perm_ok p0))) (fun _ -> ());
rewrite_slprop (pts_to r p1 v1) ((pts_to_raw r p1 v1) `star` (pure ... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.HigherReference.intro_pts_to",
"Steel.FractionalPermission.sum_perm",
"Prims.unit",
"Prims.l_and",
"Prims.eq2",
"Steel.HigherReference.perm_ok",
"Steel.HigherReference.gather_atomi... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gather (#a:Type) (#uses:_) (#p0:perm) (#p1:perm) (#v0 #v1:erased a) (r:ref a)
: SteelGhost unit uses
(pts_to r p0 v0 `star` pts_to r p1 v1)
(fun _ -> pts_to r (sum_perm p0 p1) v0)
(requires fun _ -> True)
(ensures fun _ _ _ -> v0 == v1) | [] | Steel.HigherReference.gather | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.Atomic.SteelGhost Prims.unit | {
"end_col": 35,
"end_line": 281,
"start_col": 3,
"start_line": 268
} |
Steel.Effect.SteelT | val read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v)
= let vs:erased a = witness_exists () in
rewrite_slprop (pts_to r p (Ghost.hide (Ghost.reveal vs))) (pts_to r p vs) (fun _ -> ());
le... | val read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v)
let read_refine (#a: Type) (#p: perm) (q: (a -> vprop)) (r: ref a)
: SteelT a
(h_exists (fun (v: a) -> (pts_to r p v) `star` (q v)))
... | true | null | false | let vs:erased a = witness_exists () in
rewrite_slprop (pts_to r p (Ghost.hide (Ghost.reveal vs))) (pts_to r p vs) (fun _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.FractionalPermission.perm",
"Steel.Effect.Common.vprop",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Effect.Common.VStar",
"Steel.HigherReference.pts_to",
"Prims.unit",
"Steel.Effect.Atom... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val read_refine (#a:Type) (#p:perm) (q:a -> vprop) (r:ref a)
: SteelT a (h_exists (fun (v:a) -> pts_to r p v `star` q v))
(fun v -> pts_to r p v `star` q v) | [] | Steel.HigherReference.read_refine | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | q: (_: a -> Steel.Effect.Common.vprop) -> r: Steel.HigherReference.ref a -> Steel.Effect.SteelT a | {
"end_col": 12,
"end_line": 178,
"start_col": 3,
"start_line": 171
} |
Steel.Effect.Atomic.SteelAtomic | val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a)
(r:ref a)
: SteelAtomic a opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
= let v1 : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (pts_to r p v) (RP.pts_to r v1 `star` pure (perm_ok p)) (fun _ -> ());
elim_pure (perm_ok p);
let v2 = RP.atomic_read r v1 in
rewrite_slpr... | val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a)
(r:ref a)
: SteelAtomic a opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
let atomic_read (#opened: _) (#a: Type) (#p: perm) (#v: erased a) (r: ref a) = | true | null | false | let v1:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (pts_to r p v) ((RP.pts_to r v1) `star` (pure (perm_ok p))) (fun _ -> ());
elim_pure (perm_ok p);
let v2 = RP.atomic_read r v1 in
rewrite_slprop (RP.pts_to r v1)
(pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.return",
"Steel.HigherReference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.rewrite_slprop",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val atomic_read (#opened:_) (#a:Type) (#p:perm) (#v:erased a)
(r:ref a)
: SteelAtomic a opened
(pts_to r p v)
(fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | [] | Steel.HigherReference.atomic_read | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.Atomic.SteelAtomic a | {
"end_col": 12,
"end_line": 166,
"start_col": 3,
"start_line": 154
} |
Steel.Effect.Atomic.SteelGhostT | val gather_atomic_raw (#a: Type) (#uses: _) (#p0 #p1: perm) (r: ref a) (v0 v1: erased a)
: SteelGhostT (_: unit{v0 == v1 /\ perm_ok (sum_perm p0 p1)})
uses
((pts_to_raw r p0 v0) `star` (pts_to_raw r p1 v1))
(fun _ -> pts_to_raw r (sum_perm p0 p1) v0) | [
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "... | false | let gather_atomic_raw (#a:Type) (#uses:_) (#p0 #p1:perm) (r:ref a) (v0:erased a) (v1:erased a)
: SteelGhostT (_:unit{v0==v1 /\ perm_ok (sum_perm p0 p1)}) uses
(pts_to_raw r p0 v0 `star` pts_to_raw r p1 v1)
(fun _ -> pts_to_raw r (sum_perm p0 p1) v0)
=
rewrite_slprop
(pts... | val gather_atomic_raw (#a: Type) (#uses: _) (#p0 #p1: perm) (r: ref a) (v0 v1: erased a)
: SteelGhostT (_: unit{v0 == v1 /\ perm_ok (sum_perm p0 p1)})
uses
((pts_to_raw r p0 v0) `star` (pts_to_raw r p1 v1))
(fun _ -> pts_to_raw r (sum_perm p0 p1) v0)
let gather_atomic_raw (#a: Type) (#uses: _) (#p... | true | null | false | rewrite_slprop (pts_to_raw r p0 v0)
(RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v0, p0))))
(fun _ -> ());
rewrite_slprop (pts_to_raw r p1 v1)
(RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v1, p1))))
(fun _ -> ());
let _ = RP.gather r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) in
rewrite_slpro... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.Memory.inames",
"Steel.FractionalPermission.perm",
"Steel.HigherReference.ref",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.PCM.op",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val gather_atomic_raw (#a: Type) (#uses: _) (#p0 #p1: perm) (r: ref a) (v0 v1: erased a)
: SteelGhostT (_: unit{v0 == v1 /\ perm_ok (sum_perm p0 p1)})
uses
((pts_to_raw r p0 v0) `star` (pts_to_raw r p1 v1))
(fun _ -> pts_to_raw r (sum_perm p0 p1) v0) | [] | Steel.HigherReference.gather_atomic_raw | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> v0: FStar.Ghost.erased a -> v1: FStar.Ghost.erased a
-> Steel.Effect.Atomic.SteelGhostT
(_:
Prims.unit
{v0 == v1 /\ Steel.HigherReference.perm_ok (Steel.FractionalPermission.sum_perm p0 p1)}) | {
"end_col": 19,
"end_line": 265,
"start_col": 4,
"start_line": 253
} |
Steel.Effect.Steel | val read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": ... | false | let read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
= let v1 : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (pts_to r p v) (RP.pts_to r v1 `star` pure (perm_ok p)) (fun _ -> ());
elim_pure (perm_ok p);
let v2 = RP.read r v1 in
rewrite_slprop (RP.pts_to r v1) (pts_to... | val read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v)
let read (#a: Type) (#p: perm) (#v: erased a) (r: ref a) = | true | null | false | let v1:erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
rewrite_slprop (pts_to r p v) ((RP.pts_to r v1) `star` (pure (perm_ok p))) (fun _ -> ());
elim_pure (perm_ok p);
let v2 = RP.read r v1 in
rewrite_slprop (RP.pts_to r v1)
(pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
... | {
"checked_file": "Steel.HigherReference.fst.checked",
"dependencies": [
"Steel.PCMReference.fsti.checked",
"Steel.PCMFrac.fst.checked",
"Steel.Memory.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FSta... | [] | [
"Steel.FractionalPermission.perm",
"FStar.Ghost.erased",
"Steel.HigherReference.ref",
"Steel.Effect.Atomic.return",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.HigherReference.pts_to",
"Steel.Effect.Common.vprop",
"Prims.unit",
"Steel.Effect.Atomic.rewr... | [] | (*
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... | false | false | Steel.HigherReference.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val read (#a:Type) (#p:perm) (#v:erased a) (r:ref a)
: Steel a (pts_to r p v) (fun x -> pts_to r p x)
(requires fun h -> True)
(ensures fun _ x _ -> x == Ghost.reveal v) | [] | Steel.HigherReference.read | {
"file_name": "lib/steel/Steel.HigherReference.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | r: Steel.HigherReference.ref a -> Steel.Effect.Steel a | {
"end_col": 12,
"end_line": 151,
"start_col": 3,
"start_line": 140
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arc... | false | let pow2_24 = 0x1000000 | let pow2_24 = | false | null | false | 0x1000000 | {
"checked_file": "Vale.AES.Types_helpers.fsti.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale... | [
"total"
] | [] | [] | module Vale.AES.Types_helpers
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.Lib.Seqs | false | true | Vale.AES.Types_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val pow2_24 : Prims.int | [] | Vale.AES.Types_helpers.pow2_24 | {
"file_name": "vale/code/crypto/aes/Vale.AES.Types_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Prims.int | {
"end_col": 30,
"end_line": 12,
"start_col": 21,
"start_line": 12
} | |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arc... | false | let nat24 = natN pow2_24 | let nat24 = | false | null | false | natN pow2_24 | {
"checked_file": "Vale.AES.Types_helpers.fsti.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale... | [
"total"
] | [
"Vale.Def.Words_s.natN",
"Vale.AES.Types_helpers.pow2_24"
] | [] | module Vale.AES.Types_helpers
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.Lib.Seqs | false | true | Vale.AES.Types_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val nat24 : Type0 | [] | Vale.AES.Types_helpers.nat24 | {
"file_name": "vale/code/crypto/aes/Vale.AES.Types_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type0 | {
"end_col": 24,
"end_line": 13,
"start_col": 12,
"start_line": 13
} | |
FStar.Pervasives.Lemma | val lemma_ishl_64 (x: nat64) (k: nat) : Lemma (ensures ishl #pow2_64 x k == x * pow2 k % pow2_64) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arc... | false | let lemma_ishl_64 (x:nat64) (k:nat) : Lemma
(ensures ishl #pow2_64 x k == x * pow2 k % pow2_64)
=
Vale.Def.TypesNative_s.reveal_ishl 64 x k;
FStar.UInt.shift_left_value_lemma #64 x k;
() | val lemma_ishl_64 (x: nat64) (k: nat) : Lemma (ensures ishl #pow2_64 x k == x * pow2 k % pow2_64)
let lemma_ishl_64 (x: nat64) (k: nat) : Lemma (ensures ishl #pow2_64 x k == x * pow2 k % pow2_64) = | false | null | true | Vale.Def.TypesNative_s.reveal_ishl 64 x k;
FStar.UInt.shift_left_value_lemma #64 x k;
() | {
"checked_file": "Vale.AES.Types_helpers.fsti.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale... | [
"lemma"
] | [
"Vale.Def.Types_s.nat64",
"Prims.nat",
"Prims.unit",
"FStar.UInt.shift_left_value_lemma",
"Vale.Def.TypesNative_s.reveal_ishl",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Def.Types_s.ishl",
"Vale.Def.Words_s.pow2_64",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Prims.pow... | [] | module Vale.AES.Types_helpers
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.Lib.Seqs
unfold let pow2_24 = 0x1000000
let nat24 = natN pow2_24
val lemma_slices_le_quad32_to_bytes (q:quad32) : Lemma
(ensure... | false | false | Vale.AES.Types_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_ishl_64 (x: nat64) (k: nat) : Lemma (ensures ishl #pow2_64 x k == x * pow2 k % pow2_64) | [] | Vale.AES.Types_helpers.lemma_ishl_64 | {
"file_name": "vale/code/crypto/aes/Vale.AES.Types_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.nat64 -> k: Prims.nat
-> FStar.Pervasives.Lemma
(ensures Vale.Def.Types_s.ishl x k == x * Prims.pow2 k % Vale.Def.Words_s.pow2_64) | {
"end_col": 4,
"end_line": 40,
"start_col": 2,
"start_line": 38
} |
FStar.Pervasives.Lemma | val lemma_ishr_32 (x: nat32) (k: nat) : Lemma (ensures ishr #pow2_32 x k == x / pow2 k) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arc... | false | let lemma_ishr_32 (x:nat32) (k:nat) : Lemma
(ensures ishr #pow2_32 x k == x / pow2 k)
=
Vale.Def.TypesNative_s.reveal_ishr 32 x k;
FStar.UInt.shift_right_value_lemma #32 x k;
() | val lemma_ishr_32 (x: nat32) (k: nat) : Lemma (ensures ishr #pow2_32 x k == x / pow2 k)
let lemma_ishr_32 (x: nat32) (k: nat) : Lemma (ensures ishr #pow2_32 x k == x / pow2 k) = | false | null | true | Vale.Def.TypesNative_s.reveal_ishr 32 x k;
FStar.UInt.shift_right_value_lemma #32 x k;
() | {
"checked_file": "Vale.AES.Types_helpers.fsti.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale... | [
"lemma"
] | [
"Vale.Def.Types_s.nat32",
"Prims.nat",
"Prims.unit",
"FStar.UInt.shift_right_value_lemma",
"Vale.Def.TypesNative_s.reveal_ishr",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Def.Types_s.ishr",
"Vale.Def.Words_s.pow2_32",
"Prims.op_Division",
"Prims.pow2",
"Prims.Nil",
... | [] | module Vale.AES.Types_helpers
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.Lib.Seqs
unfold let pow2_24 = 0x1000000
let nat24 = natN pow2_24
val lemma_slices_le_quad32_to_bytes (q:quad32) : Lemma
(ensure... | false | false | Vale.AES.Types_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_ishr_32 (x: nat32) (k: nat) : Lemma (ensures ishr #pow2_32 x k == x / pow2 k) | [] | Vale.AES.Types_helpers.lemma_ishr_32 | {
"file_name": "vale/code/crypto/aes/Vale.AES.Types_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.nat32 -> k: Prims.nat
-> FStar.Pervasives.Lemma (ensures Vale.Def.Types_s.ishr x k == x / Prims.pow2 k) | {
"end_col": 4,
"end_line": 54,
"start_col": 2,
"start_line": 52
} |
FStar.Pervasives.Lemma | val lemma_ishr_64 (x: nat64) (k: nat) : Lemma (ensures ishr #pow2_64 x k == x / pow2 k) | [
{
"abbrev": false,
"full_module": "Vale.Lib.Seqs",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arc... | false | let lemma_ishr_64 (x:nat64) (k:nat) : Lemma
(ensures ishr #pow2_64 x k == x / pow2 k)
=
Vale.Def.TypesNative_s.reveal_ishr 64 x k;
FStar.UInt.shift_right_value_lemma #64 x k;
() | val lemma_ishr_64 (x: nat64) (k: nat) : Lemma (ensures ishr #pow2_64 x k == x / pow2 k)
let lemma_ishr_64 (x: nat64) (k: nat) : Lemma (ensures ishr #pow2_64 x k == x / pow2 k) = | false | null | true | Vale.Def.TypesNative_s.reveal_ishr 64 x k;
FStar.UInt.shift_right_value_lemma #64 x k;
() | {
"checked_file": "Vale.AES.Types_helpers.fsti.checked",
"dependencies": [
"Vale.Lib.Seqs.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.TypesNative_s.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale... | [
"lemma"
] | [
"Vale.Def.Types_s.nat64",
"Prims.nat",
"Prims.unit",
"FStar.UInt.shift_right_value_lemma",
"Vale.Def.TypesNative_s.reveal_ishr",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"Vale.Def.Types_s.ishr",
"Vale.Def.Words_s.pow2_64",
"Prims.op_Division",
"Prims.pow2",
"Prims.Nil",
... | [] | module Vale.AES.Types_helpers
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Words.Four_s
open Vale.Def.Types_s
open Vale.Arch.Types
open FStar.Mul
open FStar.Seq
open Vale.Lib.Seqs
unfold let pow2_24 = 0x1000000
let nat24 = natN pow2_24
val lemma_slices_le_quad32_to_bytes (q:quad32) : Lemma
(ensure... | false | false | Vale.AES.Types_helpers.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_el... | null | val lemma_ishr_64 (x: nat64) (k: nat) : Lemma (ensures ishr #pow2_64 x k == x / pow2 k) | [] | Vale.AES.Types_helpers.lemma_ishr_64 | {
"file_name": "vale/code/crypto/aes/Vale.AES.Types_helpers.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.Types_s.nat64 -> k: Prims.nat
-> FStar.Pervasives.Lemma (ensures Vale.Def.Types_s.ishr x k == x / Prims.pow2 k) | {
"end_col": 4,
"end_line": 47,
"start_col": 2,
"start_line": 45
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.