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
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 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
sequencelengths 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,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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; 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; va_Mod_mem]) (va_wp_Keyhash_init win alg key roundkeys_b hkeys_b)
(va_wpProof_Keyhash_init win alg key roundkeys_b hkeys_b)) | 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)
: (va_quickCode unit (va_code_Keyhash_init win alg)) = | 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; va_Mod_mem
])
(va_wp_Keyhash_init win alg key roundkeys_b hkeys_b)
(va_wpProof_Keyhash_init win alg key roundkeys_b hkeys_b)) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.AES.X64.PolyOps.fsti.checked",
"Vale.AES.X64.GF128_Mul.fsti.checked",
"Vale.AES.X64.AES.fsti.checked",
"Vale.AES.OptPublic.fsti.checked",
"Vale.AES.GHash.fsti.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF128.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES256_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.GF128_Init.fsti"
} | [
"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",
"Vale.X64.QuickCode.va_Mod_xmm",
"Vale.X64.QuickCode.va_Mod_mem_layout",
"Vale.X64.QuickCode.va_Mod_mem_heaplet",
"Vale.X64.QuickCode.va_Mod_reg64",
"Vale.X64.Machine_s.rR12",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRdx",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRax",
"Vale.X64.QuickCode.va_Mod_mem",
"Prims.Nil",
"Vale.AES.X64.GF128_Init.va_wp_Keyhash_init",
"Vale.AES.X64.GF128_Init.va_wpProof_Keyhash_init",
"Vale.X64.QuickCode.va_quickCode"
] | [] | 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.AES.GF128
open Vale.AES.GHash
open Vale.AES.AES_s
open Vale.AES.AES256_helpers
open Vale.AES.X64.AES
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.AES.X64.PolyOps
open Vale.AES.X64.GF128_Mul
open Vale.AES.GHash
open Vale.AES.OptPublic
//-- Keyhash_init
val va_code_Keyhash_init : win:bool -> alg:algorithm -> Tot va_code
val va_codegen_success_Keyhash_init : win:bool -> alg:algorithm -> Tot va_pbool
let va_req_Keyhash_init (va_b0:va_code) (va_s0:va_state) (win:bool) (alg:algorithm) (key:(seq
nat32)) (roundkeys_b:buffer128) (hkeys_b:buffer128) : prop =
(va_require_total va_b0 (va_code_Keyhash_init win alg) va_s0 /\ va_get_ok va_s0 /\ (let
(round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (aesni_enabled /\ pclmulqdq_enabled /\
avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg = AES_256) /\
Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\ Vale.AES.AES_s.is_aes_key_LE alg key
/\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0) roundkeys_b ==
Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem
va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret))
let va_ens_Keyhash_init (va_b0:va_code) (va_s0:va_state) (win:bool) (alg:algorithm) (key:(seq
nat32)) (roundkeys_b:buffer128) (hkeys_b:buffer128) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Keyhash_init va_b0 va_s0 win alg key roundkeys_b hkeys_b /\ va_ensure_total va_b0 va_s0
va_sM va_fM /\ va_get_ok va_sM /\ (let (round_ptr:(va_int_range 0 18446744073709551615)) = (if
win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
Vale.X64.Decls.modifies_buffer128 hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\
Vale.AES.OptPublic.hkeys_reqs_pub (Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b)
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.AES_s.aes_encrypt_LE alg key
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0))) /\ va_get_xmm 6 va_sM == va_get_xmm
6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64 rR12 va_s0) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 4 va_sM
(va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rR12 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))
val va_lemma_Keyhash_init : va_b0:va_code -> va_s0:va_state -> win:bool -> alg:algorithm ->
key:(seq nat32) -> roundkeys_b:buffer128 -> hkeys_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Keyhash_init win alg) va_s0 /\ va_get_ok va_s0 /\ (let
(round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (aesni_enabled /\ pclmulqdq_enabled /\
avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg = AES_256) /\
Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\ Vale.AES.AES_s.is_aes_key_LE alg key
/\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0) roundkeys_b ==
Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem
va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win
then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Decls.modifies_buffer128
hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\ Vale.AES.OptPublic.hkeys_reqs_pub
(Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b) (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.AES_s.aes_encrypt_LE alg key (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0
0))) /\ va_get_xmm 6 va_sM == va_get_xmm 6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64
rR12 va_s0) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 6 va_sM (va_update_xmm 5
va_sM (va_update_xmm 4 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 1 va_sM
(va_update_reg64 rR12 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))
[@ va_qattr]
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_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 Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg =
AES_256) /\ Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\
Vale.AES.AES_s.is_aes_key_LE alg key /\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0)
roundkeys_b == Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128
(va_get_mem va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r12:nat64) (va_x_heap1:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_xmm4:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 6 va_x_xmm6
(va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 4 va_x_xmm4 (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 1 va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rR12 va_x_r12 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))))))))) in va_get_ok va_sM /\ (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
Vale.X64.Decls.modifies_buffer128 hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\
Vale.AES.OptPublic.hkeys_reqs_pub (Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b)
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.AES_s.aes_encrypt_LE alg key
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0))) /\ va_get_xmm 6 va_sM == va_get_xmm
6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64 rR12 va_s0) ==> va_k va_sM (())))
val va_wpProof_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)
-> Ghost (va_state & va_fuel & unit)
(requires (va_t_require va_s0 /\ va_wp_Keyhash_init win alg key roundkeys_b hkeys_b va_s0 va_k))
(ensures (fun (va_sM, va_f0, va_g) -> va_t_ensure (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; va_Mod_mem]) va_s0 va_k ((va_sM, va_f0, va_g))))
[@ "opaque_to_smt" va_qattr]
let va_quick_Keyhash_init (win:bool) (alg:algorithm) (key:(seq nat32)) (roundkeys_b:buffer128) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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,
"full_module": "Vale.AES.X64.PolyOps",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCodes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.QuickCode",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsAes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsVector",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsMem",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsBasic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Decls",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES256_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GF128_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Bits_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_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 Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg =
AES_256) /\ Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\
Vale.AES.AES_s.is_aes_key_LE alg key /\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0)
roundkeys_b == Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128
(va_get_mem va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout
va_s0) Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret) /\ (forall (va_x_mem:vale_heap) (va_x_rax:nat64)
(va_x_rcx:nat64) (va_x_rdx:nat64) (va_x_r8:nat64) (va_x_r12:nat64) (va_x_heap1:vale_heap)
(va_x_memLayout:vale_heap_layout) (va_x_xmm0:quad32) (va_x_xmm1:quad32) (va_x_xmm2:quad32)
(va_x_xmm3:quad32) (va_x_xmm4:quad32) (va_x_xmm5:quad32) (va_x_xmm6:quad32)
(va_x_efl:Vale.X64.Flags.t) . let va_sM = va_upd_flags va_x_efl (va_upd_xmm 6 va_x_xmm6
(va_upd_xmm 5 va_x_xmm5 (va_upd_xmm 4 va_x_xmm4 (va_upd_xmm 3 va_x_xmm3 (va_upd_xmm 2 va_x_xmm2
(va_upd_xmm 1 va_x_xmm1 (va_upd_xmm 0 va_x_xmm0 (va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 1 va_x_heap1 (va_upd_reg64 rR12 va_x_r12 (va_upd_reg64 rR8 va_x_r8
(va_upd_reg64 rRdx va_x_rdx (va_upd_reg64 rRcx va_x_rcx (va_upd_reg64 rRax va_x_rax (va_upd_mem
va_x_mem va_s0))))))))))))))) in va_get_ok va_sM /\ (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
Vale.X64.Decls.modifies_buffer128 hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\
Vale.AES.OptPublic.hkeys_reqs_pub (Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b)
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.AES_s.aes_encrypt_LE alg key
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0))) /\ va_get_xmm 6 va_sM == va_get_xmm
6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64 rR12 va_s0) ==> va_k va_sM (()))) | 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_b: buffer128)
(va_s0: va_state)
(va_k: (va_state -> unit -> Type0))
: Type0 = | 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
Vale.X64.Memory.is_initial_heap (va_get_mem_layout va_s0) (va_get_mem va_s0) /\
(aesni_enabled /\ pclmulqdq_enabled /\ avx_enabled /\ sse_enabled) /\
(alg = AES_128 \/ alg = AES_256) /\ Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\
Vale.AES.AES_s.is_aes_key_LE alg key /\
Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0) roundkeys_b ==
Vale.AES.AES_s.key_to_round_keys_LE alg key /\
Vale.X64.Decls.validSrcAddrs128 (va_get_mem va_s0)
round_ptr
roundkeys_b
(Vale.AES.AES_common_s.nr alg + 1)
(va_get_mem_layout va_s0)
Secret /\
Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0)
hkey_ptr
hkeys_b
8
(va_get_mem_layout va_s0)
Secret) /\
(forall (va_x_mem: vale_heap) (va_x_rax: nat64) (va_x_rcx: nat64) (va_x_rdx: nat64)
(va_x_r8: nat64) (va_x_r12: nat64) (va_x_heap1: vale_heap) (va_x_memLayout: vale_heap_layout)
(va_x_xmm0: quad32) (va_x_xmm1: quad32) (va_x_xmm2: quad32) (va_x_xmm3: quad32)
(va_x_xmm4: quad32) (va_x_xmm5: quad32) (va_x_xmm6: quad32) (va_x_efl: Vale.X64.Flags.t).
let va_sM =
va_upd_flags va_x_efl
(va_upd_xmm 6
va_x_xmm6
(va_upd_xmm 5
va_x_xmm5
(va_upd_xmm 4
va_x_xmm4
(va_upd_xmm 3
va_x_xmm3
(va_upd_xmm 2
va_x_xmm2
(va_upd_xmm 1
va_x_xmm1
(va_upd_xmm 0
va_x_xmm0
(va_upd_mem_layout va_x_memLayout
(va_upd_mem_heaplet 1
va_x_heap1
(va_upd_reg64 rR12
va_x_r12
(va_upd_reg64 rR8
va_x_r8
(va_upd_reg64 rRdx
va_x_rdx
(va_upd_reg64 rRcx
va_x_rcx
(va_upd_reg64 rRax
va_x_rax
(va_upd_mem va_x_mem va_s0))))))))
)))))))
in
va_get_ok va_sM /\
(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
Vale.X64.Decls.modifies_buffer128 hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\
Vale.AES.OptPublic.hkeys_reqs_pub (Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b)
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.AES_s.aes_encrypt_LE alg
key
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0))) /\
va_get_xmm 6 va_sM == va_get_xmm 6 va_s0 /\
va_get_reg64 rR12 va_sM == va_get_reg64 rR12 va_s0) ==>
va_k va_sM (()))) | {
"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.InsMem.fsti.checked",
"Vale.X64.InsBasic.fsti.checked",
"Vale.X64.InsAes.fsti.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Decls.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Math.Poly2_s.fsti.checked",
"Vale.Math.Poly2.Lemmas.fsti.checked",
"Vale.Math.Poly2.Bits_s.fsti.checked",
"Vale.Math.Poly2.Bits.fsti.checked",
"Vale.Math.Poly2.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.AES.X64.PolyOps.fsti.checked",
"Vale.AES.X64.GF128_Mul.fsti.checked",
"Vale.AES.X64.AES.fsti.checked",
"Vale.AES.OptPublic.fsti.checked",
"Vale.AES.GHash.fsti.checked",
"Vale.AES.GF128_s.fsti.checked",
"Vale.AES.GF128.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"Vale.AES.AES_common_s.fst.checked",
"Vale.AES.AES256_helpers.fsti.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.AES.X64.GF128_Init.fsti"
} | [
"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",
"Vale.X64.Decls.va_get_mem",
"Vale.X64.CPU_Features_s.aesni_enabled",
"Vale.X64.CPU_Features_s.pclmulqdq_enabled",
"Vale.X64.CPU_Features_s.avx_enabled",
"Vale.X64.CPU_Features_s.sse_enabled",
"Prims.l_or",
"Prims.op_Equality",
"Vale.AES.AES_common_s.AES_128",
"Vale.AES.AES_common_s.AES_256",
"Vale.X64.Decls.buffers_disjoint128",
"Vale.AES.AES_s.is_aes_key_LE",
"Prims.eq2",
"Vale.Def.Types_s.quad32",
"Vale.X64.Decls.buffer128_as_seq",
"Vale.AES.AES_s.key_to_round_keys_LE",
"Vale.X64.Decls.validSrcAddrs128",
"Prims.op_Addition",
"Vale.AES.AES_common_s.nr",
"Vale.Arch.HeapTypes_s.Secret",
"Vale.X64.Decls.validDstAddrs128",
"Vale.X64.Decls.va_int_range",
"Vale.X64.Decls.va_if",
"Vale.Def.Types_s.nat64",
"Vale.X64.Decls.va_get_reg64",
"Vale.X64.Machine_s.rRdx",
"Prims.l_not",
"Vale.X64.Machine_s.rRsi",
"Vale.X64.Machine_s.rRcx",
"Vale.X64.Machine_s.rRdi",
"Prims.l_Forall",
"Vale.X64.InsBasic.vale_heap",
"Vale.X64.Memory.nat64",
"Vale.Arch.HeapImpl.vale_heap_layout",
"Vale.X64.Decls.quad32",
"Vale.X64.Flags.t",
"Prims.l_imp",
"Vale.X64.Decls.modifies_buffer128",
"Vale.AES.OptPublic.hkeys_reqs_pub",
"Vale.X64.Decls.s128",
"Vale.Def.Types_s.reverse_bytes_quad32",
"Vale.AES.AES_s.aes_encrypt_LE",
"Vale.Def.Words_s.Mkfour",
"Vale.Def.Types_s.nat32",
"Vale.X64.Decls.va_get_xmm",
"Vale.X64.Machine_s.rR12",
"Vale.X64.State.vale_state",
"Vale.X64.Decls.va_upd_flags",
"Vale.X64.Decls.va_upd_xmm",
"Vale.X64.Decls.va_upd_mem_layout",
"Vale.X64.Decls.va_upd_mem_heaplet",
"Vale.X64.Decls.va_upd_reg64",
"Vale.X64.Machine_s.rR8",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Decls.va_upd_mem"
] | [] | 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.AES.GF128
open Vale.AES.GHash
open Vale.AES.AES_s
open Vale.AES.AES256_helpers
open Vale.AES.X64.AES
open Vale.X64.Machine_s
open Vale.X64.Memory
open Vale.X64.State
open Vale.X64.Decls
open Vale.X64.InsBasic
open Vale.X64.InsMem
open Vale.X64.InsVector
open Vale.X64.InsAes
open Vale.X64.QuickCode
open Vale.X64.QuickCodes
open Vale.X64.CPU_Features_s
open Vale.AES.X64.PolyOps
open Vale.AES.X64.GF128_Mul
open Vale.AES.GHash
open Vale.AES.OptPublic
//-- Keyhash_init
val va_code_Keyhash_init : win:bool -> alg:algorithm -> Tot va_code
val va_codegen_success_Keyhash_init : win:bool -> alg:algorithm -> Tot va_pbool
let va_req_Keyhash_init (va_b0:va_code) (va_s0:va_state) (win:bool) (alg:algorithm) (key:(seq
nat32)) (roundkeys_b:buffer128) (hkeys_b:buffer128) : prop =
(va_require_total va_b0 (va_code_Keyhash_init win alg) va_s0 /\ va_get_ok va_s0 /\ (let
(round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (aesni_enabled /\ pclmulqdq_enabled /\
avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg = AES_256) /\
Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\ Vale.AES.AES_s.is_aes_key_LE alg key
/\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0) roundkeys_b ==
Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem
va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret))
let va_ens_Keyhash_init (va_b0:va_code) (va_s0:va_state) (win:bool) (alg:algorithm) (key:(seq
nat32)) (roundkeys_b:buffer128) (hkeys_b:buffer128) (va_sM:va_state) (va_fM:va_fuel) : prop =
(va_req_Keyhash_init va_b0 va_s0 win alg key roundkeys_b hkeys_b /\ va_ensure_total va_b0 va_s0
va_sM va_fM /\ va_get_ok va_sM /\ (let (round_ptr:(va_int_range 0 18446744073709551615)) = (if
win then va_get_reg64 rRcx va_s0 else va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0
18446744073709551615)) = (if win then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in
Vale.X64.Decls.modifies_buffer128 hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\
Vale.AES.OptPublic.hkeys_reqs_pub (Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b)
(Vale.Def.Types_s.reverse_bytes_quad32 (Vale.AES.AES_s.aes_encrypt_LE alg key
(Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0 0))) /\ va_get_xmm 6 va_sM == va_get_xmm
6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64 rR12 va_s0) /\ va_state_eq va_sM
(va_update_flags va_sM (va_update_xmm 6 va_sM (va_update_xmm 5 va_sM (va_update_xmm 4 va_sM
(va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1 va_sM (va_update_xmm 0 va_sM
(va_update_mem_layout va_sM (va_update_mem_heaplet 1 va_sM (va_update_reg64 rR12 va_sM
(va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM (va_update_reg64 rRcx va_sM
(va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem va_sM va_s0))))))))))))))))))
val va_lemma_Keyhash_init : va_b0:va_code -> va_s0:va_state -> win:bool -> alg:algorithm ->
key:(seq nat32) -> roundkeys_b:buffer128 -> hkeys_b:buffer128
-> Ghost (va_state & va_fuel)
(requires (va_require_total va_b0 (va_code_Keyhash_init win alg) va_s0 /\ va_get_ok va_s0 /\ (let
(round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0 else
va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win then
va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Memory.is_initial_heap
(va_get_mem_layout va_s0) (va_get_mem va_s0) /\ (aesni_enabled /\ pclmulqdq_enabled /\
avx_enabled /\ sse_enabled) /\ (alg = AES_128 \/ alg = AES_256) /\
Vale.X64.Decls.buffers_disjoint128 roundkeys_b hkeys_b /\ Vale.AES.AES_s.is_aes_key_LE alg key
/\ Vale.X64.Decls.buffer128_as_seq (va_get_mem va_s0) roundkeys_b ==
Vale.AES.AES_s.key_to_round_keys_LE alg key /\ Vale.X64.Decls.validSrcAddrs128 (va_get_mem
va_s0) round_ptr roundkeys_b (Vale.AES.AES_common_s.nr alg + 1) (va_get_mem_layout va_s0)
Secret /\ Vale.X64.Decls.validDstAddrs128 (va_get_mem va_s0) hkey_ptr hkeys_b 8
(va_get_mem_layout va_s0) Secret)))
(ensures (fun (va_sM, va_fM) -> va_ensure_total va_b0 va_s0 va_sM va_fM /\ va_get_ok va_sM /\
(let (round_ptr:(va_int_range 0 18446744073709551615)) = (if win then va_get_reg64 rRcx va_s0
else va_get_reg64 rRdi va_s0) in let (hkey_ptr:(va_int_range 0 18446744073709551615)) = (if win
then va_get_reg64 rRdx va_s0 else va_get_reg64 rRsi va_s0) in Vale.X64.Decls.modifies_buffer128
hkeys_b (va_get_mem va_s0) (va_get_mem va_sM) /\ Vale.AES.OptPublic.hkeys_reqs_pub
(Vale.X64.Decls.s128 (va_get_mem va_sM) hkeys_b) (Vale.Def.Types_s.reverse_bytes_quad32
(Vale.AES.AES_s.aes_encrypt_LE alg key (Vale.Def.Words_s.Mkfour #Vale.Def.Types_s.nat32 0 0 0
0))) /\ va_get_xmm 6 va_sM == va_get_xmm 6 va_s0 /\ va_get_reg64 rR12 va_sM == va_get_reg64
rR12 va_s0) /\ va_state_eq va_sM (va_update_flags va_sM (va_update_xmm 6 va_sM (va_update_xmm 5
va_sM (va_update_xmm 4 va_sM (va_update_xmm 3 va_sM (va_update_xmm 2 va_sM (va_update_xmm 1
va_sM (va_update_xmm 0 va_sM (va_update_mem_layout va_sM (va_update_mem_heaplet 1 va_sM
(va_update_reg64 rR12 va_sM (va_update_reg64 rR8 va_sM (va_update_reg64 rRdx va_sM
(va_update_reg64 rRcx va_sM (va_update_reg64 rRax va_sM (va_update_ok va_sM (va_update_mem
va_sM va_s0)))))))))))))))))))
[@ va_qattr]
let va_wp_Keyhash_init (win:bool) (alg:algorithm) (key:(seq nat32)) (roundkeys_b:buffer128) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
-> Type0 | {
"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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t
-> acc:lbignum t aLen ->
limb t & lbignum t aLen | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
val bn_mul1:
#t:limb_t
-> #aLen:size_nat
-> a:lbignum t aLen
-> l:limb t ->
limb t & lbignum t aLen | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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 =
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_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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen)
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 res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc (==) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
v c * pow2 (pbits * aLen) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) - pow2 (pbits * j) * bn_v res1 + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j)) (bn_v res1) (bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen)
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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j))
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_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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i))
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_v a * v b.[i - 1] * (pow2 (pbits * (i - 1))));
calc (==) {
eval_ (aLen + bLen) resi (aLen + i);
(==) { bn_eval_unfold_i resi (aLen + i) }
eval_ (aLen + bLen) resi (aLen + i - 1) + v resi.[aLen + i - 1] * pow2 (pbits * (aLen + i - 1));
(==) { }
eval_ (aLen + bLen) resi1 (aLen + i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { }
bn_v a * eval_ bLen b (i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { Math.Lemmas.paren_mul_right (bn_v a) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
bn_v a * eval_ bLen b (i - 1) + bn_v a * (v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { Math.Lemmas.distributivity_add_right (bn_v a) (eval_ bLen b (i - 1)) (v b.[i - 1] * (pow2 (pbits * (i - 1)))) }
bn_v a * (eval_ bLen b (i - 1) + v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { bn_eval_unfold_i b i }
bn_v a * eval_ bLen b i;
};
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i)
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 a * eval_ bLen b i)
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 b) res (i - 1);
let resi1 = repeati (i - 1) (bn_mul_ a b) res in
assert (resi == bn_mul_ a b (i - 1) resi1);
bn_mul_loop_lemma a b (i - 1);
assert (eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1));
bn_mul_loop_lemma_step a b i resi1;
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i);
() end
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 * aLen) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.bn_v a * Lib.IntTypes.v l)
<:
Type0)) | {
"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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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_in_place"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.bn_v acc +
Hacl.Spec.Bignum.Definitions.bn_v a * Lib.IntTypes.v l)
<:
Type0)) | {
"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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add",
"Lib.Sequence.op_String_Access"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j)) | [
{
"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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j))
let bn_mul_lemma_ #t #aLen #bLen a b j acc = | 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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_extensionality_j",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Prims.unit",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add_lemma",
"Lib.Sequence.op_String_Access",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lshift_add"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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 =
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_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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen)
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 res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc (==) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
v c * pow2 (pbits * aLen) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) - pow2 (pbits * j) * bn_v res1 + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j)) (bn_v res1) (bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen)
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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j)) | [] | 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 in
Lib.IntTypes.v res.[ aLen + j ] * Prims.pow2 (Lib.IntTypes.bits t * (aLen + j)) +
Hacl.Spec.Bignum.Definitions.eval_ (aLen + bLen) res (aLen + j) ==
Hacl.Spec.Bignum.Definitions.eval_ (aLen + bLen) acc (aLen + j) +
(Hacl.Spec.Bignum.Definitions.bn_v a * Lib.IntTypes.v b.[ j ]) *
Prims.pow2 (Lib.IntTypes.bits t * j))) | {
"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 a * eval_ bLen b 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 b) res (i - 1);
let resi1 = repeati (i - 1) (bn_mul_ a b) res in
assert (resi == bn_mul_ a b (i - 1) resi1);
bn_mul_loop_lemma a b (i - 1);
assert (eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1));
bn_mul_loop_lemma_step a b i resi1;
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i);
() end | 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 a * eval_ bLen b i)
let rec bn_mul_loop_lemma #t #aLen #bLen a b i = | 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
assert (resi == bn_mul_ a b (i - 1) resi1);
bn_mul_loop_lemma a b (i - 1);
assert (eval_ (aLen + bLen) resi1 (aLen + i - 1) == bn_v a * eval_ bLen b (i - 1));
bn_mul_loop_lemma_step a b i resi1;
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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_zeroes",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"Lib.LoopCombinators.eq_repeati0",
"Hacl.Spec.Bignum.Multiplication.bn_mul_",
"Prims.bool",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Bignum.Definitions.eval_",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Multiplication.bn_mul_loop_lemma_step",
"Prims.op_Subtraction",
"Hacl.Spec.Bignum.Multiplication.bn_mul_loop_lemma",
"Lib.LoopCombinators.repeati",
"Lib.LoopCombinators.unfold_repeati",
"Lib.Sequence.lseq",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.l_and",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.SEC",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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 =
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_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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen)
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 res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc (==) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
v c * pow2 (pbits * aLen) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) - pow2 (pbits * j) * bn_v res1 + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j)) (bn_v res1) (bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen)
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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j))
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_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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i))
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_v a * v b.[i - 1] * (pow2 (pbits * (i - 1))));
calc (==) {
eval_ (aLen + bLen) resi (aLen + i);
(==) { bn_eval_unfold_i resi (aLen + i) }
eval_ (aLen + bLen) resi (aLen + i - 1) + v resi.[aLen + i - 1] * pow2 (pbits * (aLen + i - 1));
(==) { }
eval_ (aLen + bLen) resi1 (aLen + i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { }
bn_v a * eval_ bLen b (i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { Math.Lemmas.paren_mul_right (bn_v a) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
bn_v a * eval_ bLen b (i - 1) + bn_v a * (v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { Math.Lemmas.distributivity_add_right (bn_v a) (eval_ bLen b (i - 1)) (v b.[i - 1] * (pow2 (pbits * (i - 1)))) }
bn_v a * (eval_ bLen b (i - 1) + v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { bn_eval_unfold_i b i }
bn_v a * eval_ bLen b i;
};
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i)
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 a * eval_ bLen b i) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 a * eval_ bLen b i) | [
"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.Spec.Bignum.Multiplication.bn_mul_ a b) res
in
Hacl.Spec.Bignum.Definitions.eval_ (aLen + bLen) resi (aLen + i) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.Definitions.eval_ bLen b i)) | {
"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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end | 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_mul1_lemma_loop #t #aLen a l 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_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;
())
else
let c1, res1:generate_elem_a (limb t) (limb t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)
in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen
(bn_mul1_f a l)
(i - 1)
(generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() | {
"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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.uint",
"FStar.Seq.Base.seq",
"Prims.l_or",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_f",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.IntTypes.uint 0)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
let _ = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i * Lib.IntTypes.v l)
<:
Type0)) | {
"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) + bn_v #t #i res == eval_ aLen acc i + 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end | 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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
let rec bn_mul1_add_in_place_lemma_loop #t #aLen a l acc 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_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
())
else
let c1, res1:generate_elem_a (limb t) (limb t) aLen (i - 1) =
generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)
in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen
(bn_mul1_add_in_place_f a l acc)
(i - 1)
(generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 ==
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() | {
"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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.unit",
"Hacl.Spec.Bignum.Definitions.bn_eval0",
"FStar.Pervasives.assert_norm",
"Prims.pow2",
"Prims._assert",
"Prims.l_and",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.uint",
"FStar.Seq.Base.seq",
"Prims.l_or",
"FStar.Seq.Base.length",
"FStar.Seq.Base.empty",
"Hacl.Spec.Lib.eq_generate_elems0",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f",
"Prims.bool",
"Prims.op_Subtraction",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma_loop_step",
"FStar.Pervasives.Native.Mktuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma_loop",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Lib.generate_elems",
"Hacl.Spec.Lib.generate_elems_unfold",
"Hacl.Spec.Lib.generate_elem_a",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l) | [
"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.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f a l acc)
(Lib.IntTypes.uint 0)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
let _ = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen acc i +
Hacl.Spec.Bignum.Definitions.eval_ aLen a i * Lib.IntTypes.v l)
<:
Type0)) | {
"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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_v a * v b.[i - 1] * (pow2 (pbits * (i - 1))));
calc (==) {
eval_ (aLen + bLen) resi (aLen + i);
(==) { bn_eval_unfold_i resi (aLen + i) }
eval_ (aLen + bLen) resi (aLen + i - 1) + v resi.[aLen + i - 1] * pow2 (pbits * (aLen + i - 1));
(==) { }
eval_ (aLen + bLen) resi1 (aLen + i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { }
bn_v a * eval_ bLen b (i - 1) + bn_v a * v b.[i - 1] * (pow2 (pbits * (i - 1)));
(==) { Math.Lemmas.paren_mul_right (bn_v a) (v b.[i - 1]) (pow2 (pbits * (i - 1))) }
bn_v a * eval_ bLen b (i - 1) + bn_v a * (v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { Math.Lemmas.distributivity_add_right (bn_v a) (eval_ bLen b (i - 1)) (v b.[i - 1] * (pow2 (pbits * (i - 1)))) }
bn_v a * (eval_ bLen b (i - 1) + v b.[i - 1] * (pow2 (pbits * (i - 1))));
(==) { bn_eval_unfold_i b i }
bn_v a * eval_ bLen b i;
};
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i) | 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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i))
let bn_mul_loop_lemma_step #t #aLen #bLen a b i resi1 = | 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 ( == ) {
eval_ (aLen + bLen) resi (aLen + i);
( == ) { bn_eval_unfold_i resi (aLen + i) }
eval_ (aLen + bLen) resi (aLen + i - 1) + v resi.[ aLen + i - 1 ] * pow2 (pbits * (aLen + i - 1));
( == ) { () }
eval_ (aLen + bLen) resi1 (aLen + i - 1) + (bn_v a * v b.[ i - 1 ]) * (pow2 (pbits * (i - 1)));
( == ) { () }
bn_v a * eval_ bLen b (i - 1) + (bn_v a * v b.[ i - 1 ]) * (pow2 (pbits * (i - 1)));
( == ) { Math.Lemmas.paren_mul_right (bn_v a) (v b.[ i - 1 ]) (pow2 (pbits * (i - 1))) }
bn_v a * eval_ bLen b (i - 1) + bn_v a * (v b.[ i - 1 ] * (pow2 (pbits * (i - 1))));
( == ) { Math.Lemmas.distributivity_add_right (bn_v a)
(eval_ bLen b (i - 1))
(v b.[ i - 1 ] * (pow2 (pbits * (i - 1)))) }
bn_v a * (eval_ bLen b (i - 1) + v b.[ i - 1 ] * (pow2 (pbits * (i - 1))));
( == ) { bn_eval_unfold_i b i }
bn_v a * eval_ bLen b i;
};
assert (eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b 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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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_",
"FStar.Mul.op_Star",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Hacl.Spec.Bignum.Definitions.limb",
"Prims.pow2",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_add_right",
"Hacl.Spec.Bignum.Multiplication.bn_mul_lemma_",
"Hacl.Spec.Bignum.Multiplication.bn_mul_",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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 =
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_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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen)
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 res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc (==) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
v c * pow2 (pbits * aLen) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) - pow2 (pbits * j) * bn_v res1 + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j)) (bn_v res1) (bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen)
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 (aLen + j) ==
eval_ (aLen + bLen) acc (aLen + j) + bn_v a * v b.[j] * pow2 (bits t * j))
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_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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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
(let resi = bn_mul_ a b (i - 1) resi1 in
eval_ (aLen + bLen) resi (aLen + i) == bn_v a * eval_ bLen b i)) | [] | 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 - 1) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.Definitions.eval_ bLen b (i - 1))
(ensures
(let resi = Hacl.Spec.Bignum.Multiplication.bn_mul_ a b (i - 1) resi1 in
Hacl.Spec.Bignum.Definitions.eval_ (aLen + bLen) resi (aLen + i) ==
Hacl.Spec.Bignum.Definitions.bn_v a * Hacl.Spec.Bignum.Definitions.eval_ bLen b 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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 res2 in
bn_eval_split_i (sub res 0 (j + aLen)) j;
bn_eval_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc (==) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
v c * pow2 (pbits * aLen) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
(==) { }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) - pow2 (pbits * j) * bn_v res1 + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j)) (bn_v res1) (bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) + pow2 (pbits * j) * bn_v res2;
(==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen) | 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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen)
let bn_mul1_lshift_add_lemma #t #aLen #resLen a b_j j acc = | 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_extensionality_j res (sub res 0 (j + aLen)) (j + aLen);
assert (eval_ resLen res (j + aLen) == bn_v #t #j (sub res 0 j) + pow2 (pbits * j) * bn_v res2);
eq_intro (sub res 0 j) (sub acc 0 j);
assert (bn_v #t #j (sub res 0 j) == bn_v #t #j (sub acc 0 j));
bn_eval_split_i (sub acc 0 (j + aLen)) j;
bn_eval_extensionality_j acc (sub acc 0 (j + aLen)) (j + aLen);
assert (eval_ resLen acc (j + aLen) == bn_v #t #j (sub acc 0 j) + pow2 (pbits * j) * bn_v res1);
calc ( == ) {
v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j);
( == ) { Math.Lemmas.pow2_plus (pbits * aLen) (pbits * j) }
v c * (pow2 (pbits * aLen) * pow2 (pbits * j)) + eval_ resLen res (aLen + j);
( == ) { Math.Lemmas.paren_mul_right (v c) (pow2 (pbits * aLen)) (pow2 (pbits * j)) }
(v c * pow2 (pbits * aLen)) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
( == ) { () }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen res (aLen + j);
( == ) { () }
(bn_v res1 + bn_v a * v b_j - bn_v res2) * pow2 (pbits * j) + eval_ resLen acc (j + aLen) -
pow2 (pbits * j) * bn_v res1 +
pow2 (pbits * j) * bn_v res2;
( == ) { Math.Lemmas.distributivity_add_right (pow2 (pbits * j))
(bn_v res1)
(bn_v a * v b_j - bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j - bn_v res2) + eval_ resLen acc (j + aLen) +
pow2 (pbits * j) * bn_v res2;
( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * j)) (bn_v a * v b_j) (bn_v res2) }
pow2 (pbits * j) * (bn_v a * v b_j) + eval_ resLen acc (j + aLen);
};
assert (v c * pow2 (pbits * (aLen + j)) + eval_ resLen res (aLen + j) ==
eval_ resLen acc (aLen + j) + (bn_v a * v b_j) * pow2 (pbits * j));
eq_intro (slice res (aLen + j) resLen) (slice acc (aLen + j) resLen) | {
"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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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._assert",
"Prims.eq2",
"Prims.int",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Hacl.Spec.Bignum.Definitions.eval_",
"Hacl.Spec.Bignum.Definitions.bn_v",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.pow2_plus",
"Prims.squash",
"FStar.Math.Lemmas.paren_mul_right",
"FStar.Math.Lemmas.distributivity_add_right",
"FStar.Math.Lemmas.distributivity_sub_right",
"Lib.Sequence.sub",
"Hacl.Spec.Bignum.Definitions.bn_eval_extensionality_j",
"Hacl.Spec.Bignum.Definitions.bn_eval_split_i",
"Prims.nat",
"Lib.Sequence.lseq",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_lemma",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
#pop-options
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) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)
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);
assert (c == uint #t 0 /\ res == Seq.empty);
bn_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
bn_eval0 acc;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_add_in_place_f a l acc) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_add_in_place_f a l acc) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1));
bn_mul1_add_in_place_lemma_loop a l acc (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l);
bn_mul1_add_in_place_lemma_loop_step a l acc i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l);
() end
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 =
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_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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) ==
eval_ resLen acc (aLen + j) + bn_v a * v b_j * pow2 (bits t * j) /\
slice res (aLen + j) resLen == slice acc (aLen + j) resLen) | [] | 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_j j acc in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * (aLen + j)) +
Hacl.Spec.Bignum.Definitions.eval_ resLen res (aLen + j) ==
Hacl.Spec.Bignum.Definitions.eval_ resLen acc (aLen + j) +
(Hacl.Spec.Bignum.Definitions.bn_v a * Lib.IntTypes.v b_j) *
Prims.pow2 (Lib.IntTypes.bits t * j) /\
Lib.Sequence.slice res (aLen + j) resLen == Lib.Sequence.slice acc (aLen + j) resLen)
<:
Type0)) | {
"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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l) | 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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
let bn_mul1_lemma_loop_step #t #aLen a l i (c1, res1) = | 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;
( == ) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
( == ) { () }
v c * b2 + eval_ aLen a (i - 1) * v l - (v e + v c * pow2 pbits - v a.[ i - 1 ] * v l) * b1 +
v e * b1;
( == ) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[ i - 1 ] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[ i - 1 ] * v l) * b1;
( == ) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[ i - 1 ] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 + (v a.[ i - 1 ] * v l) * b1;
( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1;
Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) }
eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * v l) * b1;
( == ) { Math.Lemmas.paren_mul_right (v a.[ i - 1 ]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[ i - 1 ] * (b1 * v l);
( == ) { Math.Lemmas.paren_mul_right (v a.[ i - 1 ]) b1 (v l) }
eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * b1) * v l;
( == ) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[ i - 1 ] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[ i - 1 ] * b1) * v l;
( == ) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l) | {
"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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.nat",
"Lib.Sequence.length",
"Prims.op_Addition",
"Prims._assert",
"Prims.int",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.Sequence.op_String_Access",
"Prims.pow2",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_snoc",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Base.mul_wide_add",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l)) | [] | 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.Lemma
(requires
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) +
Hacl.Spec.Bignum.Definitions.bn_v res1 ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) * Lib.IntTypes.v l)
<:
Type0))
(ensures
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
let _ =
Hacl.Spec.Lib.generate_elem_f aLen
(Hacl.Spec.Bignum.Multiplication.bn_mul1_f a l)
(i - 1)
(c1, res1)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen a i * Lib.IntTypes.v l)
<:
Type0)
<:
Type0)) | {
"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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + 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": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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
assert (v e + v c * pow2 pbits == v a.[i - 1] * v l + v c1 + v acc.[i - 1]);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l - v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l + v acc.[i - 1]) b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[i - 1] * v l + v acc.[i - 1]) * b1;
(==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] * v l) (v acc.[i - 1]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1 + v acc.[i - 1] * b1;
(==) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l) | 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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l))
let bn_mul1_add_in_place_lemma_loop_step #t #aLen a l acc i (c1, res1) = | 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 ( == ) {
v c * b2 + bn_v #t #i res;
( == ) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
( == ) { () }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v e + v c * pow2 pbits - v a.[ i - 1 ] * v l - v acc.[ i - 1 ]) * b1 +
v e * b1;
( == ) { Math.Lemmas.distributivity_add_left (v e)
(v c * pow2 pbits - v a.[ i - 1 ] * v l - v acc.[ i - 1 ])
b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l -
(v c * pow2 pbits - v a.[ i - 1 ] * v l - v acc.[ i - 1 ]) * b1;
( == ) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits)
(v a.[ i - 1 ] * v l + v acc.[ i - 1 ])
b1 }
v c * b2 + eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits) * b1 +
(v a.[ i - 1 ] * v l + v acc.[ i - 1 ]) * b1;
( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1;
Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * v l + v acc.[ i - 1 ]) * b1;
( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ] * v l) (v acc.[ i - 1 ]) b1 }
eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * v l) * b1 +
v acc.[ i - 1 ] * b1;
( == ) { bn_eval_unfold_i acc i }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * v l) * b1;
( == ) { Math.Lemmas.paren_mul_right (v a.[ i - 1 ]) (v l) b1 }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + v a.[ i - 1 ] * (b1 * v l);
( == ) { Math.Lemmas.paren_mul_right (v a.[ i - 1 ]) b1 (v l) }
eval_ aLen acc i + eval_ aLen a (i - 1) * v l + (v a.[ i - 1 ] * b1) * v l;
( == ) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[ i - 1 ] * b1) (v l) }
eval_ aLen acc i + (eval_ aLen a (i - 1) + v a.[ i - 1 ] * b1) * v l;
( == ) { bn_eval_unfold_i a i }
eval_ aLen acc i + eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l) | {
"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.Base.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Bignum.Multiplication.fst"
} | [
"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.nat",
"Lib.Sequence.length",
"Prims.op_Addition",
"Prims._assert",
"Prims.int",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.SEC",
"Hacl.Spec.Bignum.Definitions.bn_v",
"Hacl.Spec.Bignum.Definitions.eval_",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"FStar.Calc.calc_step",
"Lib.Sequence.op_String_Access",
"Prims.pow2",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"Hacl.Spec.Bignum.Definitions.bn_eval_snoc",
"Prims.squash",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.paren_mul_right",
"Hacl.Spec.Bignum.Definitions.bn_eval_unfold_i",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Base.mul_wide_add2",
"Hacl.Spec.Lib.generate_elem_f",
"Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.bits"
] | [] | 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 aLen
-> l:limb t
-> i:size_nat{i < aLen}
-> c:limb t ->
limb t & limb t // carry & out
let bn_mul1_f #t #aLen a l i c =
mul_wide_add a.[i] l c
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 =
generate_elems aLen aLen (bn_mul1_f a l) (uint #t 0)
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 // carry & out
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:
#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 =
generate_elems aLen aLen (bn_mul1_add_in_place_f a l acc) (uint #t 0)
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 =
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_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 =
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 ->
lbignum t (aLen + bLen)
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_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) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i * v l))
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 l + v c1);
calc (==) {
v c * b2 + bn_v #t #i res;
(==) { bn_eval_snoc #t #(i - 1) res1 e }
v c * b2 + bn_v #t #(i - 1) res1 + v e * b1;
(==) { }
v c * b2 + eval_ aLen a (i - 1) * v l -(v e + v c * pow2 pbits - v a.[i - 1] * v l) * b1 + v e * b1;
(==) { Math.Lemmas.distributivity_add_left (v e) (v c * pow2 pbits - v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - (v c * pow2 pbits - v a.[i - 1] * v l) * b1;
(==) { Math.Lemmas.distributivity_sub_left (v c * pow2 pbits) (v a.[i - 1] * v l) b1 }
v c * b2 + eval_ aLen a (i - 1) * v l - v c * pow2 pbits * b1 + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) b1; Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * v l * b1;
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) (v l) b1 }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * (b1 * v l);
(==) { Math.Lemmas.paren_mul_right (v a.[i - 1]) b1 (v l) }
eval_ aLen a (i - 1) * v l + v a.[i - 1] * b1 * v l;
(==) { Math.Lemmas.distributivity_add_left (eval_ aLen a (i - 1)) (v a.[i - 1] * b1) (v l) }
(eval_ aLen a (i - 1) + v a.[i - 1] * b1) * v l;
(==) { bn_eval_unfold_i a i }
eval_ aLen a i * v l;
};
assert (v c * b2 + bn_v #t #i res == eval_ aLen a i * v l)
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_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_eval0 #t #0 res;
assert_norm (pow2 0 = 1);
bn_eval0 a;
() end
else begin
let (c1, res1) : generate_elem_a (limb t) (limb t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0) in
generate_elems_unfold aLen i (bn_mul1_f a l) (uint #t 0) (i - 1);
assert (generate_elems aLen i (bn_mul1_f a l) (uint #t 0) ==
generate_elem_f aLen (bn_mul1_f a l) (i - 1) (generate_elems aLen (i - 1) (bn_mul1_f a l) (uint #t 0)));
assert ((c, res) == generate_elem_f aLen (bn_mul1_f a l) (i - 1) (c1, res1));
bn_mul1_lemma_loop a l (i - 1);
assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) * v l);
bn_mul1_lemma_loop_step a l i (c1, res1);
assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i * v l);
() end
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 =
let (c, res) = bn_mul1 a l in
bn_mul1_lemma_loop a l aLen
#push-options "--z3rlimit 150"
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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 150,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 - 1) res1 == eval_ aLen acc (i - 1) + eval_ aLen a (i - 1) * v l))
(ensures
(let (c1, res1) = c1_res1 in
let (c, res) = generate_elem_f aLen (bn_mul1_add_in_place_f a l acc) (i - 1) (c1, res1) in
v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen acc i + eval_ aLen a i * v l)) | [] | 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)
aLen
(i - 1)
-> FStar.Pervasives.Lemma
(requires
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) +
Hacl.Spec.Bignum.Definitions.bn_v res1 ==
Hacl.Spec.Bignum.Definitions.eval_ aLen acc (i - 1) +
Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) * Lib.IntTypes.v l)
<:
Type0))
(ensures
(let _ = c1_res1 in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in
let _ =
Hacl.Spec.Lib.generate_elem_f aLen
(Hacl.Spec.Bignum.Multiplication.bn_mul1_add_in_place_f a l acc)
(i - 1)
(c1, res1)
in
(let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in
Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) +
Hacl.Spec.Bignum.Definitions.bn_v res ==
Hacl.Spec.Bignum.Definitions.eval_ aLen acc i +
Hacl.Spec.Bignum.Definitions.eval_ aLen a i * Lib.IntTypes.v l)
<:
Type0)
<:
Type0)) | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_Subtraction",
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"FStar.Mul.op_Star"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 (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))] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"FStar.UInt32.v",
"Prims.squash",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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
)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
[SMTPat (FStar.Krml.Endianness.n_to_be len (FStar.Krml.Endianness.be_to_n 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"FStar.Mul.op_Star"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 (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))] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Seq.Base.length",
"FStar.UInt32.v",
"Prims.squash",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"FStar.Krml.Endianness.bytes",
"Prims.nat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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
)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
[SMTPat (FStar.Krml.Endianness.n_to_le len (FStar.Krml.Endianness.le_to_n 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"FStar.Mul.op_Star"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end | 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))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Krml.Endianness.be_to_n",
"Prims.squash",
"FStar.Seq.Base.equal",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
(decreases FStar.Seq.Base.length b1) | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_of_be",
"FStar.Krml.Endianness.seq_uint32_of_be",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_of_be",
"FStar.Krml.Endianness.seq_uint64_of_be",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"FStar.Mul.op_Star"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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)
: 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)))) = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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",
"FStar.Seq.Base.slice",
"FStar.Mul.op_Star",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_base")]
let be_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
be_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint32 s1)))
[ SMTPat (be_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.le_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.le_of_seq_uint32_base")]
let le_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
le_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (le_of_seq_uint32 s1)))
[ SMTPat (le_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint64_append")]
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_cons #U64.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint64 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint64 (S.head s1)) (be_of_seq_uint64 (S.append (S.tail s1) s2))));
be_of_seq_uint64_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint64_base")]
let be_of_seq_uint64_base (s1: S.seq U64.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 8 /\
be_to_n s2 = U64.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint64 s1)))
[ SMTPat (be_to_n s2 = U64.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.seq_uint32_of_be_be_of_seq_uint32")]
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.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_uint32 (S.tail s))
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_seq_uint32_of_be")]
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_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' == seq_uint32_of_be (n - 1) tl);
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_uint32 (S.tail s'));
n_to_be_be_to_n 4ul hd
end
[@(deprecated "FStar.Endianness.slice_seq_uint32_of_be")]
let slice_seq_uint32_of_be (n: nat) (s: S.seq U8.t) (lo: nat) (hi: nat) : Lemma
(requires (4 * n == S.length s /\ lo <= hi /\ hi <= n))
(ensures (S.slice (seq_uint32_of_be n s) lo hi) `S.equal` seq_uint32_of_be (hi - lo) (S.slice s (4 * lo) (4 * hi)))
= ()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_slice")]
let be_of_seq_uint32_slice (s: S.seq U32.t) (lo: nat) (hi: nat) : Lemma
(requires (lo <= hi /\ hi <= S.length s)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Endianness.be_of_seq_uint32 s) (4 * lo) (4 * hi))) | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end | 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))
(ensures (Seq.equal b1 b2))
(decreases (Seq.length b1)) = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_to_n",
"Prims.squash",
"FStar.Seq.Base.equal",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
(decreases FStar.Seq.Base.length b1) | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_of_le",
"FStar.Krml.Endianness.seq_uint64_of_le",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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_of_le",
"FStar.Krml.Endianness.seq_uint32_of_le",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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 | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end | 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)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert (be_to_n b <= pow2 8 * (be_to_n s + 1));
assert (be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.op_LessThanOrEqual",
"FStar.Krml.Endianness.be_to_n",
"Prims.pow2",
"Prims.op_Addition",
"FStar.Krml.Endianness.lemma_euclidean_division",
"FStar.UInt8.v",
"FStar.Seq.Properties.last",
"Prims.op_LessThan",
"FStar.Krml.Endianness.lemma_be_to_n_is_bounded",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b | 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' (S.slice b 0 (U32.v len));
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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.slice",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.append",
"FStar.Seq.Base.create",
"FStar.Krml.Endianness.bytes",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.Seq.Base.length",
"FStar.Krml.Endianness.be_to_n",
"FStar.Krml.Endianness.n_to_be",
"Prims._assert",
"FStar.Math.Lemmas.pow2_plus",
"Prims.op_Division",
"FStar.UInt8.uint_to_t",
"Prims.op_Modulus",
"FStar.UInt32.op_Subtraction_Hat",
"FStar.UInt32.n"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end | 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)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert (le_to_n b <= pow2 8 * (le_to_n s + 1));
assert (le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.op_LessThanOrEqual",
"FStar.Krml.Endianness.le_to_n",
"Prims.pow2",
"Prims.op_Addition",
"FStar.Krml.Endianness.lemma_euclidean_division",
"FStar.UInt8.v",
"FStar.Seq.Base.index",
"Prims.op_LessThan",
"FStar.Krml.Endianness.lemma_le_to_n_is_bounded",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.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_uint32 (S.tail s))
end | 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)
: 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))] = | 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_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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Endianness.be_of_seq_uint32",
"FStar.Seq.Properties.tail",
"Prims.unit",
"FStar.Seq.Properties.lemma_split",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Multiply",
"FStar.Krml.Endianness.seq_uint32_of_be_be_of_seq_uint32",
"Prims.op_Subtraction",
"Prims._assert",
"FStar.Seq.Base.equal",
"FStar.Seq.Properties.cons",
"Prims.eq2",
"Prims.squash",
"FStar.Krml.Endianness.seq_uint32_of_be",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_base")]
let be_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
be_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint32 s1)))
[ SMTPat (be_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.le_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.le_of_seq_uint32_base")]
let le_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
le_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (le_of_seq_uint32 s1)))
[ SMTPat (le_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint64_append")]
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_cons #U64.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint64 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint64 (S.head s1)) (be_of_seq_uint64 (S.append (S.tail s1) s2))));
be_of_seq_uint64_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint64_base")]
let be_of_seq_uint64_base (s1: S.seq U64.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 8 /\
be_to_n s2 = U64.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint64 s1)))
[ SMTPat (be_to_n s2 = U64.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.seq_uint32_of_be_be_of_seq_uint32")]
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Krml.Endianness.seq_uint32_of_be n (FStar.Krml.Endianness.be_of_seq_uint32 s))] | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_intro b' (S.tail b);
b | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Properties.tail",
"FStar.Seq.Base.seq",
"FStar.Seq.Properties.cons",
"FStar.Krml.Endianness.bytes",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.Seq.Base.length",
"FStar.Krml.Endianness.le_to_n",
"FStar.Krml.Endianness.n_to_le",
"Prims._assert",
"FStar.Math.Lemmas.pow2_plus",
"Prims.op_Division",
"FStar.UInt8.uint_to_t",
"Prims.op_Modulus",
"FStar.UInt32.op_Subtraction_Hat",
"FStar.UInt32.n"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.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) | 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: 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)] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.tuple2",
"FStar.Seq.Properties.split",
"Prims.l_and",
"Prims.b2t",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"Prims.squash",
"Prims.eq2",
"FStar.UInt32.t",
"FStar.Seq.Base.index",
"FStar.Krml.Endianness.seq_uint32_of_be",
"FStar.Krml.Endianness.uint32_of_be",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + 4)))
(decreases FStar.Seq.Base.length b)
[SMTPat (FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint32_of_be n b) 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.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) | 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: 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)] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.tuple2",
"FStar.Seq.Properties.split",
"Prims.l_and",
"Prims.b2t",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"Prims.squash",
"Prims.eq2",
"FStar.UInt64.t",
"FStar.Seq.Base.index",
"FStar.Krml.Endianness.seq_uint64_of_be",
"FStar.Krml.Endianness.uint64_of_be",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + 8)))
(decreases FStar.Seq.Base.length b)
[SMTPat (FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint64_of_be n b) 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.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) | 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: 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)] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.tuple2",
"FStar.Seq.Properties.split",
"Prims.l_and",
"Prims.b2t",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"Prims.squash",
"Prims.eq2",
"FStar.UInt32.t",
"FStar.Seq.Base.index",
"FStar.Krml.Endianness.seq_uint32_of_le",
"FStar.Krml.Endianness.uint32_of_le",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + 4)))
(decreases FStar.Seq.Base.length b)
[SMTPat (FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint32_of_le n b) 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_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' == seq_uint32_of_be (n - 1) tl);
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_uint32 (S.tail s'));
n_to_be_be_to_n 4ul hd
end | 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.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))] = | 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' == seq_uint32_of_be (n - 1) tl);
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_uint32 (S.tail s'));
n_to_be_be_to_n 4ul hd) | {
"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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Endianness.be_of_uint32",
"FStar.Seq.Properties.head",
"FStar.UInt32.t",
"FStar.Krml.Endianness.be_of_seq_uint32",
"FStar.Seq.Properties.tail",
"FStar.Seq.Properties.lemma_split",
"FStar.Krml.Endianness.bytes",
"Prims.b2t",
"Prims.op_Multiply",
"Prims._assert",
"Prims.eq2",
"FStar.Krml.Endianness.seq_uint32_of_be",
"Prims.op_Subtraction",
"FStar.Krml.Endianness.tail_cons",
"FStar.Krml.Endianness.uint32_of_be",
"FStar.Pervasives.Native.tuple2",
"FStar.Seq.Properties.split",
"FStar.Krml.Endianness.be_of_seq_uint32_seq_uint32_of_be",
"FStar.Mul.op_Star",
"Prims.squash",
"FStar.Seq.Base.equal",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_base")]
let be_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
be_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint32 s1)))
[ SMTPat (be_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.le_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.le_of_seq_uint32_base")]
let le_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
le_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (le_of_seq_uint32 s1)))
[ SMTPat (le_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint64_append")]
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_cons #U64.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint64 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint64 (S.head s1)) (be_of_seq_uint64 (S.append (S.tail s1) s2))));
be_of_seq_uint64_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint64_base")]
let be_of_seq_uint64_base (s1: S.seq U64.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 8 /\
be_to_n s2 = U64.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint64 s1)))
[ SMTPat (be_to_n s2 = U64.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.seq_uint32_of_be_be_of_seq_uint32")]
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.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_uint32 (S.tail s))
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_seq_uint32_of_be")]
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 n)
[SMTPat (FStar.Krml.Endianness.be_of_seq_uint32 (FStar.Krml.Endianness.seq_uint32_of_be n s))] | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.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) | 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: 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)] = | 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.tuple2",
"FStar.Seq.Properties.split",
"Prims.l_and",
"Prims.b2t",
"FStar.Mul.op_Star",
"Prims.op_LessThan",
"Prims.squash",
"Prims.eq2",
"FStar.UInt64.t",
"FStar.Seq.Base.index",
"FStar.Krml.Endianness.seq_uint64_of_le",
"FStar.Krml.Endianness.uint64_of_le",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 + 8)))
(decreases FStar.Seq.Base.length b)
[SMTPat (FStar.Seq.Base.index (FStar.Krml.Endianness.seq_uint64_of_le n b) 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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail s1) s2
end | 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_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))] = | 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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Endianness.le_of_seq_uint32_append",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.le_of_uint32",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.cons",
"FStar.Classical.forall_intro_2",
"FStar.Krml.Endianness.tail_cons",
"Prims.l_True",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_base")]
let be_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
be_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint32 s1)))
[ SMTPat (be_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.le_of_seq_uint32_append")]
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)) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Krml.Endianness.le_of_seq_uint32 s2)))
(decreases FStar.Seq.Base.length s1)
[
SMTPat (FStar.Seq.Base.append (FStar.Krml.Endianness.le_of_seq_uint32 s1)
(FStar.Krml.Endianness.le_of_seq_uint32 s2))
] | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_cons #U64.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint64 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint64 (S.head s1)) (be_of_seq_uint64 (S.append (S.tail s1) s2))));
be_of_seq_uint64_append (S.tail s1) s2
end | 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_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))] = | 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))
(S.append (be_of_uint64 (S.head s1)) (be_of_seq_uint64 (S.append (S.tail s1) s2))));
be_of_seq_uint64_append (S.tail 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Endianness.be_of_seq_uint64_append",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.be_of_uint64",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.cons",
"FStar.Classical.forall_intro_2",
"FStar.Krml.Endianness.tail_cons",
"Prims.l_True",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.be_of_seq_uint32_base")]
let be_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
be_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (be_of_seq_uint32 s1)))
[ SMTPat (be_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.le_of_seq_uint32_append")]
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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (le_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (le_of_uint32 (S.head s1)) (le_of_seq_uint32 (S.append (S.tail s1) s2))));
le_of_seq_uint32_append (S.tail s1) s2
end
[@(deprecated "FStar.Endianness.le_of_seq_uint32_base")]
let le_of_seq_uint32_base (s1: S.seq U32.t) (s2: S.seq U8.t): Lemma
(requires (
S.length s1 = 1 /\
S.length s2 = 4 /\
le_to_n s2 = U32.v (S.index s1 0)))
(ensures (S.equal s2 (le_of_seq_uint32 s1)))
[ SMTPat (le_to_n s2 = U32.v (S.index s1 0)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint64_append")]
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)) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Krml.Endianness.be_of_seq_uint64 s2)))
(decreases FStar.Seq.Base.length s1)
[
SMTPat (FStar.Seq.Base.append (FStar.Krml.Endianness.be_of_seq_uint64 s1)
(FStar.Krml.Endianness.be_of_seq_uint64 s2))
] | {
"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": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.UInt8",
"short_module": "U8"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Krml",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_cons #U32.t); // TODO: this is a local pattern, remove once tail_cons lands in FStar.Seq.Properties
if S.length s1 = 0 then begin
assert (S.equal (be_of_seq_uint32 s1) S.empty);
assert (S.equal (S.append s1 s2) s2);
()
end else begin
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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail s1) s2
end | 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_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))] = | 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))
(S.append (be_of_uint32 (S.head s1)) (be_of_seq_uint32 (S.append (S.tail s1) s2))));
be_of_seq_uint32_append (S.tail 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.fst.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Krml.Endianness.fst"
} | [
"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.Endianness.be_of_seq_uint32_append",
"FStar.Seq.Properties.tail",
"FStar.Krml.Endianness.be_of_uint32",
"FStar.Seq.Properties.head",
"FStar.Seq.Properties.cons",
"FStar.Classical.forall_intro_2",
"FStar.Krml.Endianness.tail_cons",
"Prims.l_True",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | 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 noextract
type bytes = S.seq U8.t
/// lt_to_n interprets a byte sequence as a little-endian natural number
[@(deprecated "FStar.Endianness.le_to_n")]
val le_to_n : b:bytes -> Tot nat (decreases (S.length b))
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)
/// be_to_n interprets a byte sequence as a big-endian natural number
[@(deprecated "FStar.Endianness.be_to_n")]
val be_to_n : b:bytes -> Tot nat (decreases (S.length b))
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))
[@(deprecated "FStar.Endianness.lemma_euclidean_division")]
private val lemma_euclidean_division: r:nat -> b:nat -> q:pos -> Lemma
(requires (r < q))
(ensures (r + q * b < q * (b+1)))
let lemma_euclidean_division r b q = ()
[@(deprecated "FStar.Endianness.lemma_factorise")]
private val lemma_factorise: a:nat -> b:nat -> Lemma (a + a * b == a * (b + 1))
let lemma_factorise a b = ()
[@(deprecated "FStar.Endianness.lemma_le_to_n_is_bounded")]
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 =
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 < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.index b 0)) (le_to_n s) (pow2 8);
assert(le_to_n b <= pow2 8 * (le_to_n s + 1));
assert(le_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
[@(deprecated "FStar.Endianness.lemma_be_to_n_is_bounded")]
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 =
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 b < pow2 8 + pow2 8 * pow2 (8 * (Seq.length b - 1)));
lemma_euclidean_division (UInt8.v (Seq.last b)) (be_to_n s) (pow2 8);
assert(be_to_n b <= pow2 8 * (be_to_n s + 1));
assert(be_to_n b <= pow2 8 * pow2 (8 * (Seq.length b - 1)));
Math.Lemmas.pow2_plus 8 (8 * (Seq.length b - 1));
lemma_factorise 8 (Seq.length b - 1)
end
/// n_to_le encodes a number as a little-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_le")]
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 =
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_intro b' (S.tail b);
b
/// n_to_be encodes a numbers as a big-endian byte sequence of a fixed,
/// sufficiently large length
[@(deprecated "FStar.Endianness.n_to_be")]
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 =
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.append b' b'' in
S.lemma_eq_intro b' (S.slice b 0 (U32.v len));
b
[@(deprecated "FStar.Endianness.n_to_le_inj")]
let n_to_le_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_le len n1 == n_to_le len n2))
(ensures (n1 == n2)) =
// this lemma easily follows from le_to_n . (n_to_le len) == id, the inversion
// proof in the spec for n_to_le
()
[@(deprecated "FStar.Endianness.n_to_be_inj")]
let n_to_be_inj (len:U32.t) (n1 n2: (n:nat{n < pow2 (8 * U32.v len)})) :
Lemma (requires (n_to_be len n1 == n_to_be len n2))
(ensures (n1 == n2)) =
()
[@(deprecated "FStar.Endianness.be_to_n_inj")]
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));
Seq.lemma_split b1 (Seq.length b1 - 1);
Seq.lemma_split b2 (Seq.length b2 - 1)
end
[@(deprecated "FStar.Endianness.le_to_n_inj")]
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));
Seq.lemma_split b1 1;
Seq.lemma_split b2 1
end
[@(deprecated "FStar.Endianness.n_to_be_be_to_n")]
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))
[@(deprecated "FStar.Endianness.n_to_le_le_to_n")]
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))
(** A series of specializations to deal with machine integers *)
[@(deprecated "FStar.Endianness.uint32_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint32")]
let le_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_le 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint32_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint32")]
let be_of_uint32 (x: UInt32.t): b:bytes{ S.length b = 4 } =
n_to_be 4ul (UInt32.v x)
[@(deprecated "FStar.Endianness.uint64_of_le")]
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
[@(deprecated "FStar.Endianness.le_of_uint64")]
let le_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_le 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.uint64_of_be")]
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
[@(deprecated "FStar.Endianness.be_of_uint64")]
let be_of_uint64 (x: UInt64.t): b:bytes{ S.length b = 8 } =
n_to_be 8ul (UInt64.v x)
[@(deprecated "FStar.Endianness.seq_uint32_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint32_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint32")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_le")]
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)
[@(deprecated "FStar.Endianness.le_of_seq_uint64")]
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))
[@(deprecated "FStar.Endianness.seq_uint64_of_be")]
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)
[@(deprecated "FStar.Endianness.be_of_seq_uint64")]
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))
#set-options "--max_fuel 1 --max_ifuel 0 --z3rlimit 50"
[@(deprecated "FStar.Endianness.offset_uint32_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint32_le")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_be")]
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.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)
[@(deprecated "FStar.Endianness.offset_uint64_le")]
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.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)
(** Reasoning about endian-ness and words. *)
#set-options "--max_fuel 1 --z3rlimit 20"
(* TODO: move to FStar.Seq.Properties, with the pattern *)
[@(deprecated "FStar.Endianness.tail_cons")]
let tail_cons (#a: Type) (hd: a) (tl: S.seq a): Lemma
(ensures (S.equal (S.tail (S.cons hd tl)) tl))
// [ SMTPat (S.tail (S.cons hd tl)) ]
=
()
[@(deprecated "FStar.Endianness.be_of_seq_uint32_append")]
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)) ] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Krml.Endianness.be_of_seq_uint32 s2)))
(decreases FStar.Seq.Base.length s1)
[
SMTPat (FStar.Seq.Base.append (FStar.Krml.Endianness.be_of_seq_uint32 s1)
(FStar.Krml.Endianness.be_of_seq_uint32 s2))
] | {
"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 r = feval h0 (gsub p 0ul 5ul) in
(feval h1 out).[0] == Vec.normalize_2 r.[0] (feval h0 out))) | [
{
"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,
"full_module": "Hacl.Spec.Poly1305.Field32xN.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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) in
let r20 = r2.(0ul) in
let r21 = r2.(1ul) in
let r22 = r2.(2ul) in
let r23 = r2.(3ul) in
let r24 = r2.(4ul) in
let (o0, o1, o2, o3, o4) =
fmul_r2_normalize5 (a0, a1, a2, a3, a4) (r10, r11, r12, r13, r14) (r20, r21, r22, r23, r24) in
out.(0ul) <- o0;
out.(1ul) <- o1;
out.(2ul) <- o2;
out.(3ul) <- o3;
out.(4ul) <- o4 | 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 r = feval h0 (gsub p 0ul 5ul) in
(feval h1 out).[0] == Vec.normalize_2 r.[0] (feval h0 out)))
let fmul_r2_normalize out p = | 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 = r2.(2ul) in
let r23 = r2.(3ul) in
let r24 = r2.(4ul) in
let o0, o1, o2, o3, o4 =
fmul_r2_normalize5 (a0, a1, a2, a3, a4) (r10, r11, r12, r13, r14) (r20, r21, r22, r23, r24)
in
out.(0ul) <- o0;
out.(1ul) <- o1;
out.(2ul) <- o2;
out.(3ul) <- o3;
out.(4ul) <- o4 | {
"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.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Field32xN_128.fst"
} | [] | [
"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.Pervasives.Native.Mktuple5",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | 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.Field32xN
/// See comments in Hacl.Impl.Poly1305.Field32xN_256
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50 --using_facts_from '* -FStar.Seq'"
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.load_acc2 (as_seq h0 b) (feval h0 acc).[0])
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 = e.(4ul) in
let (acc0, acc1, acc2, acc3, acc4) =
load_acc5_2 (acc0, acc1, acc2, acc3, acc4) (e0, e1, e2, e3, e4) in
acc.(0ul) <- acc0;
acc.(1ul) <- acc1;
acc.(2ul) <- acc2;
acc.(3ul) <- acc3;
acc.(4ul) <- acc4;
pop_frame()
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 r = feval h0 (gsub p 0ul 5ul) in | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 r = feval h0 (gsub p 0ul 5ul) in
(feval h1 out).[0] == Vec.normalize_2 r.[0] (feval h0 out))) | [] | 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.load_acc2 (as_seq h0 b) (feval h0 acc).[0]) | [
{
"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,
"full_module": "Hacl.Spec.Poly1305.Field32xN.Lemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Poly1305.Field32xN",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 = e.(4ul) in
let (acc0, acc1, acc2, acc3, acc4) =
load_acc5_2 (acc0, acc1, acc2, acc3, acc4) (e0, e1, e2, e3, e4) in
acc.(0ul) <- acc0;
acc.(1ul) <- acc1;
acc.(2ul) <- acc2;
acc.(3ul) <- acc3;
acc.(4ul) <- acc4;
pop_frame() | 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.load_acc2 (as_seq h0 b) (feval h0 acc).[0])
let load_acc2 acc b = | 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 =
load_acc5_2 (acc0, acc1, acc2, acc3, acc4) (e0, e1, e2, e3, e4)
in
acc.(0ul) <- acc0;
acc.(1ul) <- acc1;
acc.(2ul) <- acc2;
acc.(3ul) <- acc3;
acc.(4ul) <- acc4;
pop_frame () | {
"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.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Poly1305.Field32xN_128.fst"
} | [] | [
"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.Field32xN.load_acc5_2",
"FStar.Pervasives.Native.Mktuple5",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"Hacl.Impl.Poly1305.Field32xN.load_blocks",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Hacl.Spec.Poly1305.Field32xN.zero",
"FStar.HyperStack.ST.push_frame"
] | [] | 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.Field32xN
/// See comments in Hacl.Impl.Poly1305.Field32xN_256
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50 --using_facts_from '* -FStar.Seq'"
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.load_acc2 (as_seq h0 b) (feval h0 acc).[0]) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.load_acc2 (as_seq h0 b) (feval h0 acc).[0]) | [] | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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",
"FStar.Ghost.reveal",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__] | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `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));
(equiv) { (star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d) a ((c `star` b) `star` d)) }
(a `star` ((c `star` b) `star` d));
(equiv) { (star_associative c b d;
star_congruence a ((c `star` b) `star` d) a (c `star` (b `star` d))) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
} | {
"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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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.Memory.star_congruence",
"Steel.Memory.star_commutative",
"Prims.l_True",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
let abcd_acbd (a b c d:slprop)
: Lemma (Mem.(((a `star` b) `star` (c `star` d)) `equiv` | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_null r (Some (Ghost.reveal v, p)) m | 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 interp (pts_to_sl r p v) m) (ensures r =!= null) = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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",
"FStar.Ghost.hide",
"Prims.unit",
"Steel.Memory.affine_star",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.Memory.pure",
"Steel.HigherReference.perm_ok",
"Steel.Memory.interp",
"Steel.HigherReference.pts_to_sl",
"Prims.squash",
"Prims.l_not",
"Prims.eq2",
"Steel.HigherReference.null",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ()) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p)) | 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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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.Ghost.erased",
"FStar.Ghost.reveal",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil",
"Steel.Memory.pts_to_join",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.HigherReference.ref",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Prims.l_True"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = () | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 20,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m | 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.((p `star` q) `star` s) m) = | 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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
((p `star` q) `star` s) `star` r;
};
assert (interp (((p `star` q) `star` s) `star` r) m);
affine_star ((p `star` q) `star` s) r 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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_init",
"FStar.Calc.calc_pack",
"Steel.Memory.star_associative",
"Prims.squash",
"Steel.HigherReference.equiv_ext_right",
"Steel.Memory.star_commutative",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
let cas_action_helper (p q r s:slprop) (m:mem)
: Lemma
(requires interp Mem.(p `star` q `star` r `star` s) m) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.interp (Steel.Memory.star (Steel.Memory.star p q) s) m) | {
"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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m | 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)
: Lemma (requires interp ((pts_to_sl r p0 v0) `Mem.star` (pts_to_sl r p1 v1)) m)
(ensures v0 == v1) = | 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.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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",
"FStar.Ghost.hide",
"Prims.unit",
"Steel.Memory.affine_star",
"Steel.Memory.star",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.Memory.pure",
"Steel.HigherReference.perm_ok",
"Steel.HigherReference.abcd_acbd",
"Steel.Memory.interp",
"Steel.HigherReference.pts_to_sl",
"Prims.squash",
"Prims.eq2",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
(Steel.HigherReference.pts_to_sl r p1 v1))
m) (ensures v0 == v1) | {
"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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y)) | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Steel.Memory.pts_to_join",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Steel.Memory.is_witness_invariant"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r
let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r
let ghost_free #a #u #v r =
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);
as_atomic_action_ghost (free_action u r v_old);
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 `star` p;
(equiv) { star_commutative p r }
p `star` 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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.Memory.equiv_extensional_on_star",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 equiv_ext_right (p q r:slprop)
: Lemma
(requires q `Mem.equiv` r) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 _ _ _ -> x0 == x1) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 _ _ _ -> x0 == x1)
let ghost_gather r = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r
let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r
let ghost_free #a #u #v r =
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);
as_atomic_action_ghost (free_action u r v_old);
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac))) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 _ _ _ -> x0 == x1) | [] | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_injective_eq #_ #_ #p0 #p1 r v0 v1 = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r
let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r
let ghost_free #a #u #v r =
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);
as_atomic_action_ghost (free_action u r v_old);
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
let ghost_share r = share (reveal r)
let ghost_gather r = gather (reveal r) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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",
"Prims.unit",
"Steel.HigherReference.ghost_write_aux"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r
let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r
let ghost_free #a #u #v r =
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);
as_atomic_action_ghost (free_action u r v_old);
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
let ghost_share r = share (reveal r)
let ghost_gather r = gather (reveal r)
let ghost_pts_to_injective_eq #_ #_ #p0 #p1 r v0 v1 =
higher_ref_pts_to_injective_eq #_ #_ #p0 #p1 #v0 #v1 (reveal r)
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.pts_to r v_old `star` pure (perm_ok p))
(ghost_pts_to r p v)
(fun _ -> ())
let ghost_read #a #u #p #v r
= 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 = as_atomic_action_ghost (sel_action u 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));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
x
let ghost_write_aux (#a:Type) (#u:_) (#v:erased a) (r:ref a) (x:a)
: SteelGhostT unit u
(pts_to r full_perm v)
(fun _ -> pts_to r full_perm (Ghost.hide x))
= let v_old : erased (fractional a) = Ghost.hide (Some (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);
as_atomic_action_ghost (Mem.upd_action u r v_old v_new);
rewrite_slprop (RP.pts_to r v_new)
(pts_to r full_perm (hide x))
(fun m -> emp_unit (hp_of (pts_to_raw r full_perm (hide x)));
pure_star_interp (hp_of (pts_to_raw r full_perm (hide x))) (perm_ok full_perm) m) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
(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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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)
(ensures fun _ _ _ -> v0 == v1)
let higher_ref_pts_to_injective_eq #a #opened #p0 #p1 #v0 #v1 r = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.star",
"Prims.eq2",
"Steel.HigherReference.pts_to_ref_injective"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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)
(ensures fun _ _ _ -> v0 == v1) | [] | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 r p v) (fun _ -> ()) | 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
(pts_to_raw r p v)
(fun _ -> pts_to r p v)
(requires fun _ -> perm_ok p)
(ensures fun _ _ _ -> True) = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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_pure",
"Steel.HigherReference.perm_ok",
"Steel.HigherReference.pts_to_raw",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.rmem",
"Prims.l_True"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v) | [
{
"abbrev": true,
"full_module": "Steel.PCMReference",
"short_module": "RP"
},
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b | val cas_action (#t:Type) (eq: (x:t -> y:t -> b:bool{b <==> (x == y)}))
(#uses:inames)
(r:ref t)
(v:erased t)
(v_old:t)
(v_new:t)
: action_except (b:bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v)
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 v_new: t)
(fr: slprop)
: MstTot (b: bool{b <==> (Ghost.reveal v == v_old)})
uses
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True) = | 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)
`star`
(locks_invariant uses m0))
m0);
cas_action_helper (Mem.pts_to r fv) (Mem.pure (perm_ok full_perm)) fr (locks_invariant uses m0) m0;
assert (interp Mem.(((pts_to r fv) `star` (pure (perm_ok full_perm)))
`star`
(locks_invariant uses m0))
m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then
(Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr;
true)
else false
in
b | {
"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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [
"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.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.Memory.mem",
"Prims.l_True",
"Prims.prop",
"Steel.Memory.pure",
"Steel.HigherReference.perm_ok",
"Steel.FractionalPermission.full_perm",
"Steel.Memory.upd_action",
"Prims._assert",
"FStar.Ghost.hide",
"FStar.PCM.compatible",
"Steel.Memory.sel_action",
"Steel.Memory.interp",
"Steel.Memory.star",
"Steel.Memory.locks_invariant",
"Steel.HigherReference.cas_action_helper",
"Steel.HigherReference.pts_to_sl",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Steel.Memory.full_mem",
"FStar.NMSTTotal.get",
"Steel.Memory.mem_evolves",
"Steel.HigherReference.cas_provides"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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 r full_perm v)
(fun b -> if b then pts_to_sl r full_perm v_new else pts_to_sl r full_perm v) | [] | 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.FractionalPermission.full_perm (FStar.Ghost.reveal v)
)
(fun b ->
(match b with
| true -> Steel.HigherReference.pts_to_sl r Steel.FractionalPermission.full_perm v_new
| _ ->
Steel.HigherReference.pts_to_sl r
Steel.FractionalPermission.full_perm
(FStar.Ghost.reveal v))
<:
Steel.Memory.slprop) | {
"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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.pts_to r v_old `star` pure (perm_ok p))
(ghost_pts_to r p v)
(fun _ -> ()) | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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",
"Steel.Effect.Common.pure",
"Steel.HigherReference.perm_ok",
"Steel.HigherReference.ghost_pts_to",
"Steel.Memory.mem",
"Prims.unit",
"Steel.Effect.Atomic.intro_pure",
"Steel.Effect.Atomic.elim_pure",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ())
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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r
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 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 `star` p;
(equiv) { star_commutative p r }
p `star` r;
}
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) {
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 `star` q) `star` (s `star` r);
(equiv) { star_associative (p `star` q) s r }
(p `star` q `star` s) `star` r;
};
assert (interp ((p `star` q `star` s) `star` r) m);
affine_star (p `star` q `star` s) r m
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
(pts_to_sl r full_perm v)
(cas_provides r v v_new)
fr
(fun _ -> True)
(fun _ _ _ -> True)
= 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 `star` locks_invariant uses m0) m0);
cas_action_helper (Mem.pts_to r fv)
(Mem.pure (perm_ok full_perm))
fr
(locks_invariant uses m0)
m0;
assert (interp Mem.((pts_to r fv `star` pure (perm_ok full_perm)) `star` locks_invariant uses m0) m0);
let fv_actual = Mem.frame (Mem.pure (perm_ok full_perm)) (sel_action uses r fv) fr in
assert (compatible pcm_frac fv fv_actual);
let Some (v', p) = fv_actual in
assert (v == Ghost.hide v');
assert (p == full_perm);
let b =
if eq v' v_old
then (Mem.frame (Mem.pure (perm_ok full_perm)) (upd_action uses r fv fv') fr; true)
else false
in
b
(*** GHOST REFERENCES ***)
let ghost_ref a = erased (ref a)
[@@__reduce__]
let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
let reveal_ghost_ref _ = ()
let reveal_ghost_pts_to_sl _ _ _ = ()
#push-options "--z3rlimit 20 --warn_error -271"
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_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 p x) m /\ interp (ghost_pts_to_sl r p y) m ==> x == y);
assert (is_witness_invariant (ghost_pts_to_sl r p))
#pop-options
let ghost_alloc_aux (#a:Type) (#u:_) (x:a)
: SteelGhostT (ref a) u
emp
(fun r -> pts_to r full_perm (Ghost.hide x))
= let v : fractional a = Some (x, full_perm) in
assert (FStar.PCM.composable pcm_frac v None);
assert (compatible pcm_frac v v);
rewrite_slprop emp (to_vprop Mem.emp) (fun _ -> reveal_emp());
let r : ref a = as_atomic_action_ghost (Steel.Memory.alloc_action u 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 full_perm) m);
r
let ghost_alloc x =
let r = ghost_alloc_aux (reveal x) in
hide r
let ghost_free #a #u #v r =
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);
as_atomic_action_ghost (free_action u r v_old);
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
let ghost_share r = share (reveal r)
let ghost_gather r = gather (reveal r)
let ghost_pts_to_injective_eq #_ #_ #p0 #p1 r v0 v1 =
higher_ref_pts_to_injective_eq #_ #_ #p0 #p1 #v0 #v1 (reveal r) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m) | 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 (RP.pts_to r v_new)
(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 full_perm) 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.Memory.pure_star_interp",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"FStar.Ghost.hide",
"Steel.HigherReference.perm_ok",
"Prims.unit",
"Steel.Memory.emp_unit",
"Steel.PCMReference.atomic_write",
"Steel.Effect.Atomic.elim_pure",
"FStar.Ghost.reveal",
"Steel.Effect.Common.star",
"Steel.Effect.Common.pure",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r | 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 full_perm) m);
extract_info_raw (pts_to r full_perm x) (~(is_null r)) (fun m -> pts_to_not_null r full_perm x m);
return 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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",
"Prims.l_not",
"Prims.b2t",
"Steel.HigherReference.is_null",
"Steel.Memory.mem",
"Steel.HigherReference.pts_to_not_null",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.PCMReference.pts_to",
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.pcm_frac",
"Steel.Memory.pure_star_interp",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.HigherReference.perm_ok",
"Steel.Memory.emp_unit",
"Steel.Memory.ref",
"Steel.PCMReference.alloc",
"Prims._assert",
"FStar.PCM.compatible",
"FStar.PCM.composable",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.Some",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ()) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 _ -> ());
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_perm p) v0)
(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)
: 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)) = | 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_perm p) 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
"Steel.FractionalPermission.half_perm",
"Steel.HigherReference.pts_to_raw",
"Steel.Memory.mem",
"Prims.unit",
"FStar.Ghost.hide",
"Steel.PCMReference.split",
"Steel.Effect.Common.star",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac))) | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.__proj__Mkpcm__item__p",
"Prims.unit",
"Steel.PCMReference.free",
"Steel.Effect.Atomic.elim_pure",
"Steel.HigherReference.perm_ok",
"Steel.FractionalPermission.full_perm",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.star",
"Steel.Effect.Common.pure",
"Steel.Memory.mem",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Mktuple2",
"Steel.Effect.Common.emp",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
let free (#a:Type) (#v:erased a) (r:ref a) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m) | 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.pts_to r v_new)
(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 full_perm) 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.FractionalPermission.full_perm",
"Steel.Memory.mem",
"Steel.Memory.pure_star_interp",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.HigherReference.perm_ok",
"Prims.unit",
"Steel.Memory.emp_unit",
"Steel.PCMReference.write",
"Steel.Effect.Atomic.elim_pure",
"FStar.Ghost.reveal",
"Steel.Effect.Common.star",
"Steel.Effect.Common.pure",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Mktuple2",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
let write (#a:Type) (#v:erased a) (r:ref a) (x:a) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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)
(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 | 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_to r (half_perm p) v) `star` (pts_to r (half_perm p) v)) = | 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.perm_ok",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.HigherReference.pts_to'",
"Steel.Memory.mem",
"Steel.PCMFrac.fractional",
"FStar.Ghost.hide",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"Steel.Effect.Common.star",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
let share (#a:Type) #uses (#p:perm) (#v:erased a) (r:ref a)
: SteelGhostT unit uses
(pts_to r p v) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 `star` pure (perm_ok p0))
(fun _ -> ());
rewrite_slprop
(pts_to r p1 v1)
(pts_to_raw r p1 v1 `star` pure (perm_ok p1))
(fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) r | 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: erased a) (r: ref a) = | 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 (perm_ok p1))) (fun _ -> ());
elim_pure (perm_ok p0);
elim_pure (perm_ok p1);
let _ = gather_atomic_raw r v0 v1 in
intro_pts_to (sum_perm p0 p1) 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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_atomic_raw",
"Steel.Effect.Atomic.elim_pure",
"Steel.Effect.Atomic.rewrite_slprop",
"Steel.HigherReference.pts_to",
"FStar.Ghost.reveal",
"Steel.Effect.Common.star",
"Steel.HigherReference.pts_to_raw",
"Steel.Effect.Common.pure",
"Steel.Memory.mem",
"Steel.PCMFrac.fractional",
"FStar.Ghost.hide",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ()) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v | 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)))
(fun v -> (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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.Atomic.rewrite_slprop",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
"Steel.HigherReference.read",
"FStar.Ghost.erased",
"Steel.Effect.Atomic.witness_exists",
"Steel.Effect.Atomic.h_exists",
"Steel.Effect.Common.star"
] | [] | (*
Copyright 2020 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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)) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x | 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));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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",
"Steel.PCMFrac.fractional",
"Prims._assert",
"FStar.PCM.compatible",
"Steel.PCMFrac.pcm_frac",
"Steel.PCMReference.pts_to",
"Steel.Memory.pure_star_interp",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.HigherReference.perm_ok",
"Steel.Memory.emp_unit",
"Steel.PCMReference.atomic_read",
"Steel.Effect.Atomic.elim_pure",
"Steel.Effect.Common.star",
"Steel.Effect.Common.pure",
"FStar.Ghost.hide",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "Steel.PCMFrac",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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_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_slprop
(RP.pts_to r _)
(pts_to_raw r (sum_perm p0 p1) v0)
(fun _ -> ()) | 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: _) (#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) = | 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_slprop (RP.pts_to r _) (pts_to_raw r (sum_perm p0 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.Native.tuple2",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
"Steel.HigherReference.pts_to_raw",
"Steel.FractionalPermission.sum_perm",
"Steel.Memory.mem",
"Prims.unit",
"FStar.PCM.composable",
"FStar.Ghost.hide",
"Steel.PCMReference.gather",
"Prims.l_and",
"Prims.eq2",
"Steel.HigherReference.perm_ok",
"Steel.Effect.Common.star",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r
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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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_slprop (RP.pts_to r v1) (pts_to r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x
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 _ -> ());
let v = read r in
rewrite_slprop (q vs) (q v) (fun _ -> ());
return v
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_old `star` pure (perm_ok full_perm)) (fun _ -> ());
elim_pure (perm_ok full_perm);
RP.write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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);
RP.atomic_write r v_old v_new;
rewrite_slprop (RP.pts_to r v_new) (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 full_perm) m)
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 _ -> ());
elim_pure (perm_ok full_perm);
RP.free r v_old;
drop (RP.pts_to r (Mkpcm'?.one (Mkpcm?.p pcm_frac)))
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 _ -> ());
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_perm p) v0)
(fun _ -> ())
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)
(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
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) | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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": "FStar.PCM",
"short_module": null
},
{
"abbrev": true,
"full_module": "Steel.Memory",
"short_module": "Mem"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Atomic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Ghost",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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 r p v)
(fun m ->
emp_unit (hp_of (pts_to_raw r p v));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return x | 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));
pure_star_interp (hp_of (pts_to_raw r p v)) (perm_ok p) m);
assert (compatible pcm_frac v1 v2);
let Some (x, _) = v2 in
rewrite_slprop (pts_to r p v) (pts_to r p x) (fun _ -> ());
return 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",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.NMSTTotal.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": true,
"source_file": "Steel.HigherReference.fst"
} | [] | [
"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.rewrite_slprop",
"FStar.Ghost.reveal",
"Steel.Memory.mem",
"Steel.PCMFrac.fractional",
"Prims._assert",
"FStar.PCM.compatible",
"Steel.PCMFrac.pcm_frac",
"Steel.PCMReference.pts_to",
"Steel.Memory.pure_star_interp",
"Steel.Effect.Common.hp_of",
"Steel.HigherReference.pts_to_raw",
"Steel.HigherReference.perm_ok",
"Steel.Memory.emp_unit",
"Steel.PCMReference.read",
"Steel.Effect.Atomic.elim_pure",
"Steel.Effect.Common.star",
"Steel.Effect.Common.pure",
"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 in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module Steel.HigherReference
open FStar.Ghost
open Steel.Memory
open Steel.Effect.Atomic
open Steel.Effect
open FStar.PCM
open Steel.PCMFrac
open FStar.Real
module RP = Steel.PCMReference
#set-options "--ide_id_info_off"
module Mem = Steel.Memory
let ref a = Mem.ref (fractional a) pcm_frac
let null #a = Mem.null #(fractional a) #pcm_frac
let is_null #a r = Mem.is_null #(fractional a) #pcm_frac r
let perm_ok p : prop = (p.v <=. one == true) /\ True
let pts_to_raw_sl (#a:Type) (r:ref a) (p:perm) (v:erased a) : slprop =
Mem.pts_to r (Some (Ghost.reveal v, p))
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)))
[@@__reduce__]
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)
let pts_to_sl #a r p v = hp_of (pts_to' r p v)
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))));
(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));
(equiv) { star_commutative b c;
star_congruence (b `star` c) d (c `star` b) d;
star_congruence a ((b `star` c) `star` d)
a ((c `star` b) `star` d) }
(a `star` ((c `star` b) `star` d));
(equiv) { star_associative c b d;
star_congruence a ((c `star` b) `star` d)
a (c `star` (b `star` d)) }
(a `star` (c `star` (b `star` d)));
(equiv) { star_associative a c (b `star` d) }
((a `star` c) `star` (b `star` d));
}
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))
(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.reveal v0, p0))
(Some (Ghost.reveal v1, p1))
m
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_null r (Some (Ghost.reveal v, p)) m
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 y, p)) m
in
Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
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 _ -> ())
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
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 r p v) (fun _ -> ())
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_raw r full_perm x)) (perm_ok full_perm) m
);
extract_info_raw (pts_to r full_perm x) (~ (is_null r))
(fun m -> pts_to_not_null r full_perm x m);
return r | 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_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.Types_helpers.fsti"
} | [
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.Types_helpers.fsti"
} | [
"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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.Types_helpers.fsti"
} | [
"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.pow2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | 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
(ensures (
let s = le_quad32_to_bytes q in
q.lo0 == four_to_nat 8 (seq_to_four_LE (slice s 0 4)) /\
q.lo1 == four_to_nat 8 (seq_to_four_LE (slice s 4 8)) /\
q.hi2 == four_to_nat 8 (seq_to_four_LE (slice s 8 12)) /\
q.hi3 == four_to_nat 8 (seq_to_four_LE (slice s 12 16))
))
val lemma_slices_be_quad32_to_bytes (q:quad32) : Lemma
(ensures (
let s = be_quad32_to_bytes q in
q.hi3 == four_to_nat 8 (seq_to_four_BE (slice s 0 4)) /\
q.hi2 == four_to_nat 8 (seq_to_four_BE (slice s 4 8)) /\
q.lo1 == four_to_nat 8 (seq_to_four_BE (slice s 8 12)) /\
q.lo0 == four_to_nat 8 (seq_to_four_BE (slice s 12 16))
))
val lemma_BitwiseXorWithZero64 (n:nat64) : Lemma (ixor n 0 == n)
let lemma_ishl_64 (x:nat64) (k:nat) : Lemma
(ensures ishl #pow2_64 x k == x * pow2 k % pow2_64) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.Types_helpers.fsti"
} | [
"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",
"FStar.Pervasives.pattern"
] | [] | 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
(ensures (
let s = le_quad32_to_bytes q in
q.lo0 == four_to_nat 8 (seq_to_four_LE (slice s 0 4)) /\
q.lo1 == four_to_nat 8 (seq_to_four_LE (slice s 4 8)) /\
q.hi2 == four_to_nat 8 (seq_to_four_LE (slice s 8 12)) /\
q.hi3 == four_to_nat 8 (seq_to_four_LE (slice s 12 16))
))
val lemma_slices_be_quad32_to_bytes (q:quad32) : Lemma
(ensures (
let s = be_quad32_to_bytes q in
q.hi3 == four_to_nat 8 (seq_to_four_BE (slice s 0 4)) /\
q.hi2 == four_to_nat 8 (seq_to_four_BE (slice s 4 8)) /\
q.lo1 == four_to_nat 8 (seq_to_four_BE (slice s 8 12)) /\
q.lo0 == four_to_nat 8 (seq_to_four_BE (slice s 12 16))
))
val lemma_BitwiseXorWithZero64 (n:nat64) : Lemma (ixor n 0 == n)
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;
()
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;
()
let lemma_ishr_32 (x:nat32) (k:nat) : Lemma
(ensures ishr #pow2_32 x k == x / pow2 k) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Four_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | 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.Arch.Types.fsti.checked",
"prims.fst.checked",
"FStar.UInt.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.AES.Types_helpers.fsti"
} | [
"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",
"FStar.Pervasives.pattern"
] | [] | 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
(ensures (
let s = le_quad32_to_bytes q in
q.lo0 == four_to_nat 8 (seq_to_four_LE (slice s 0 4)) /\
q.lo1 == four_to_nat 8 (seq_to_four_LE (slice s 4 8)) /\
q.hi2 == four_to_nat 8 (seq_to_four_LE (slice s 8 12)) /\
q.hi3 == four_to_nat 8 (seq_to_four_LE (slice s 12 16))
))
val lemma_slices_be_quad32_to_bytes (q:quad32) : Lemma
(ensures (
let s = be_quad32_to_bytes q in
q.hi3 == four_to_nat 8 (seq_to_four_BE (slice s 0 4)) /\
q.hi2 == four_to_nat 8 (seq_to_four_BE (slice s 4 8)) /\
q.lo1 == four_to_nat 8 (seq_to_four_BE (slice s 8 12)) /\
q.lo0 == four_to_nat 8 (seq_to_four_BE (slice s 12 16))
))
val lemma_BitwiseXorWithZero64 (n:nat64) : Lemma (ixor n 0 == n)
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;
()
let lemma_ishr_64 (x:nat64) (k:nat) : Lemma
(ensures ishr #pow2_64 x k == x / pow2 k) | 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_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | 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.