Datasets:

microsoft

/

FStarDataSet

like 2

Follow

Microsoft 5.63k

Prims.Tot

let a_spec (a:fixed_len_alg) (i:nat) = Seq.lseq uint8 (if i = 0 then 0 else hash_length a)

let a_spec (a: fixed_len_alg) (i: nat) =

Seq.lseq uint8 (if i = 0 then 0 else hash_length a)

module Spec.Agile.HKDF open FStar.Integers open Spec.Hash.Definitions /// FUNCTIONAL SPECIFICATION: /// /// * extraction is just HMAC using the salt as key and the input /// keying materials as text. /// /// * expansion does its own formatting of input key materials. open FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" let extract = Spec.Agile.HMAC.hmac module Seq = Lib.Sequence open Lib.IntTypes /// HKDF-Expand(PRK, info, L) /// /// N = ceil(L/HashLen) /// T = T(1) | T(2) | T(3) | ... | T(N) /// OKM = first L octets of T /// /// where: /// T(0) = empty string (zero length) /// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01) /// T(2) = HMAC-Hash(PRK, T(1) | info | 0x02) /// T(3) = HMAC-Hash(PRK, T(2) | info | 0x03) /// /// See https://tools.ietf.org/html/rfc5869#section-2.3 /// The type of T(i) is [a_spec a i]

Spec.Agile.HKDF.fst

val a_spec : a: Spec.Hash.Definitions.fixed_len_alg -> i: FStar.Integers.nat -> Type0

Spec.Agile.HKDF.a_spec

a: Spec.Hash.Definitions.fixed_len_alg -> i: FStar.Integers.nat -> Type0

Prims.Pure

val extract: a: fixed_len_alg -> key: bytes -> data: bytes -> Pure (lbytes (hash_length a)) (requires Spec.Agile.HMAC.keysized a (Seq.length key) /\ extract_ikm_length_pred a (Seq.length data)) (ensures fun _ -> True)

let extract = Spec.Agile.HMAC.hmac

val extract: a: fixed_len_alg -> key: bytes -> data: bytes -> Pure (lbytes (hash_length a)) (requires Spec.Agile.HMAC.keysized a (Seq.length key) /\ extract_ikm_length_pred a (Seq.length data)) (ensures fun _ -> True) let extract =

Spec.Agile.HMAC.hmac

module Spec.Agile.HKDF open FStar.Integers open Spec.Hash.Definitions /// FUNCTIONAL SPECIFICATION: /// /// * extraction is just HMAC using the salt as key and the input /// keying materials as text. /// /// * expansion does its own formatting of input key materials. open FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50"

Spec.Agile.HKDF.fst

val extract: a: fixed_len_alg -> key: bytes -> data: bytes -> Pure (lbytes (hash_length a)) (requires Spec.Agile.HMAC.keysized a (Seq.length key) /\ extract_ikm_length_pred a (Seq.length data)) (ensures fun _ -> True)

Spec.Agile.HKDF.extract

a: Spec.Hash.Definitions.fixed_len_alg -> key: Spec.Hash.Definitions.bytes -> data: Spec.Hash.Definitions.bytes -> Prims.Pure (Spec.Agile.HKDF.lbytes (Spec.Hash.Definitions.hash_length a))

Prims.Pure

val expand_loop: a:fixed_len_alg -> prk:bytes -> info:bytes -> n:nat -> i:nat{i < n} -> a_spec a i -> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a)) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ (hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\ n <= 255) (ensures fun _ -> True)

let expand_loop a prk info n i tag = let t = Spec.Agile.HMAC.hmac a prk (tag @| info @| Seq.create 1 (u8 (i + 1))) in t, t

val expand_loop: a:fixed_len_alg -> prk:bytes -> info:bytes -> n:nat -> i:nat{i < n} -> a_spec a i -> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a)) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ (hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\ n <= 255) (ensures fun _ -> True) let expand_loop a prk info n i tag =

let t = Spec.Agile.HMAC.hmac a prk (tag @| info @| Seq.create 1 (u8 (i + 1))) in t, t

module Spec.Agile.HKDF open FStar.Integers open Spec.Hash.Definitions /// FUNCTIONAL SPECIFICATION: /// /// * extraction is just HMAC using the salt as key and the input /// keying materials as text. /// /// * expansion does its own formatting of input key materials. open FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" let extract = Spec.Agile.HMAC.hmac module Seq = Lib.Sequence open Lib.IntTypes /// HKDF-Expand(PRK, info, L) /// /// N = ceil(L/HashLen) /// T = T(1) | T(2) | T(3) | ... | T(N) /// OKM = first L octets of T /// /// where: /// T(0) = empty string (zero length) /// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01) /// T(2) = HMAC-Hash(PRK, T(1) | info | 0x02) /// T(3) = HMAC-Hash(PRK, T(2) | info | 0x03) /// /// See https://tools.ietf.org/html/rfc5869#section-2.3 /// The type of T(i) is [a_spec a i] let a_spec (a:fixed_len_alg) (i:nat) = Seq.lseq uint8 (if i = 0 then 0 else hash_length a) /// The main loop that computes T(i) val expand_loop: a:fixed_len_alg -> prk:bytes -> info:bytes -> n:nat -> i:nat{i < n} -> a_spec a i -> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a)) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ (hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\ n <= 255)

Spec.Agile.HKDF.fst

val expand_loop: a:fixed_len_alg -> prk:bytes -> info:bytes -> n:nat -> i:nat{i < n} -> a_spec a i -> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a)) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ (hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\ n <= 255) (ensures fun _ -> True)

Spec.Agile.HKDF.expand_loop

a: Spec.Hash.Definitions.fixed_len_alg -> prk: Spec.Hash.Definitions.bytes -> info: Spec.Hash.Definitions.bytes -> n: FStar.Integers.nat -> i: FStar.Integers.nat{i < n} -> tag: Spec.Agile.HKDF.a_spec a i -> Prims.Pure (Spec.Agile.HKDF.a_spec a (i + 1) * Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.Hash.Definitions.hash_length a))

Prims.Pure

val expand: a: fixed_len_alg -> prk: bytes -> info: bytes -> len: nat -> Pure (lbytes len) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ expand_info_length_pred a (Seq.length info) /\ expand_output_length_pred a len) (ensures fun _ -> True)

let expand a prk info len = let open Spec.Agile.HMAC in let tlen = hash_length a in let n = len / tlen in let tag, output = Seq.generate_blocks tlen n n (a_spec a) (expand_loop a prk info n) FStar.Seq.empty in if n * tlen < len then let t = hmac a prk (tag @| info @| Seq.create 1 (u8 (n + 1))) in output @| Seq.sub #_ #tlen t 0 (len - (n * tlen)) else output

val expand: a: fixed_len_alg -> prk: bytes -> info: bytes -> len: nat -> Pure (lbytes len) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ expand_info_length_pred a (Seq.length info) /\ expand_output_length_pred a len) (ensures fun _ -> True) let expand a prk info len =

let open Spec.Agile.HMAC in let tlen = hash_length a in let n = len / tlen in let tag, output = Seq.generate_blocks tlen n n (a_spec a) (expand_loop a prk info n) FStar.Seq.empty in if n * tlen < len then let t = hmac a prk (tag @| info @| Seq.create 1 (u8 (n + 1))) in output @| Seq.sub #_ #tlen t 0 (len - (n * tlen)) else output

module Spec.Agile.HKDF open FStar.Integers open Spec.Hash.Definitions /// FUNCTIONAL SPECIFICATION: /// /// * extraction is just HMAC using the salt as key and the input /// keying materials as text. /// /// * expansion does its own formatting of input key materials. open FStar.Seq #set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 50" let extract = Spec.Agile.HMAC.hmac module Seq = Lib.Sequence open Lib.IntTypes /// HKDF-Expand(PRK, info, L) /// /// N = ceil(L/HashLen) /// T = T(1) | T(2) | T(3) | ... | T(N) /// OKM = first L octets of T /// /// where: /// T(0) = empty string (zero length) /// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01) /// T(2) = HMAC-Hash(PRK, T(1) | info | 0x02) /// T(3) = HMAC-Hash(PRK, T(2) | info | 0x03) /// /// See https://tools.ietf.org/html/rfc5869#section-2.3 /// The type of T(i) is [a_spec a i] let a_spec (a:fixed_len_alg) (i:nat) = Seq.lseq uint8 (if i = 0 then 0 else hash_length a) /// The main loop that computes T(i) val expand_loop: a:fixed_len_alg -> prk:bytes -> info:bytes -> n:nat -> i:nat{i < n} -> a_spec a i -> Pure (a_spec a (i + 1) & Seq.lseq uint8 (hash_length a)) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ (hash_length a + Seq.length info + 1 + block_length a) `less_than_max_input_length` a /\ n <= 255) (ensures fun _ -> True) let expand_loop a prk info n i tag = let t = Spec.Agile.HMAC.hmac a prk (tag @| info @| Seq.create 1 (u8 (i + 1))) in t, t /// Expands first computes T(0) | T(1) | ... | T(floor(L/HashLen)) in a loop and then /// if needed computes T(N) and appends as many bytes as required to complete OKM

Spec.Agile.HKDF.fst

val expand: a: fixed_len_alg -> prk: bytes -> info: bytes -> len: nat -> Pure (lbytes len) (requires hash_length a <= Seq.length prk /\ HMAC.keysized a (Seq.length prk) /\ expand_info_length_pred a (Seq.length info) /\ expand_output_length_pred a len) (ensures fun _ -> True)

Spec.Agile.HKDF.expand

a: Spec.Hash.Definitions.fixed_len_alg -> prk: Spec.Hash.Definitions.bytes -> info: Spec.Hash.Definitions.bytes -> len: FStar.Integers.nat -> Prims.Pure (Spec.Agile.HKDF.lbytes len)

Prims.Tot

val bn_sub_eq_len_u32 (aLen: size_t) : bn_sub_eq_len_st U32 aLen

let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen

val bn_sub_eq_len_u32 (aLen: size_t) : bn_sub_eq_len_st U32 aLen let bn_sub_eq_len_u32 (aLen: size_t) : bn_sub_eq_len_st U32 aLen =

bn_sub_eq_len aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

Hacl.Bignum.Addition.fst

val bn_sub_eq_len_u32 (aLen: size_t) : bn_sub_eq_len_st U32 aLen

Hacl.Bignum.Addition.bn_sub_eq_len_u32

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_sub_eq_len_st Lib.IntTypes.U32 aLen

Prims.Tot

val bn_sub_eq_len_u64 (aLen: size_t) : bn_sub_eq_len_st U64 aLen

let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen

val bn_sub_eq_len_u64 (aLen: size_t) : bn_sub_eq_len_st U64 aLen let bn_sub_eq_len_u64 (aLen: size_t) : bn_sub_eq_len_st U64 aLen =

bn_sub_eq_len aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

Hacl.Bignum.Addition.fst

val bn_sub_eq_len_u64 (aLen: size_t) : bn_sub_eq_len_st U64 aLen

Hacl.Bignum.Addition.bn_sub_eq_len_u64

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_sub_eq_len_st Lib.IntTypes.U64 aLen

Prims.Tot

val bn_add_eq_len_u64 (aLen: size_t) : bn_add_eq_len_st U64 aLen

let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen

val bn_add_eq_len_u64 (aLen: size_t) : bn_add_eq_len_st U64 aLen let bn_add_eq_len_u64 (aLen: size_t) : bn_add_eq_len_st U64 aLen =

bn_add_eq_len aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

Hacl.Bignum.Addition.fst

val bn_add_eq_len_u64 (aLen: size_t) : bn_add_eq_len_st U64 aLen

Hacl.Bignum.Addition.bn_add_eq_len_u64

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_add_eq_len_st Lib.IntTypes.U64 aLen

Prims.Tot

val bn_add_eq_len_u32 (aLen: size_t) : bn_add_eq_len_st U32 aLen

let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen

val bn_add_eq_len_u32 (aLen: size_t) : bn_add_eq_len_st U32 aLen let bn_add_eq_len_u32 (aLen: size_t) : bn_add_eq_len_st U32 aLen =

bn_add_eq_len aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

Hacl.Bignum.Addition.fst

val bn_add_eq_len_u32 (aLen: size_t) : bn_add_eq_len_st U32 aLen

Hacl.Bignum.Addition.bn_add_eq_len_u32

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_add_eq_len_st Lib.IntTypes.U32 aLen

Prims.Tot

val bn_sub_eq_len_u (#t: limb_t) (aLen: size_t) : bn_sub_eq_len_st t aLen

let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen

val bn_sub_eq_len_u (#t: limb_t) (aLen: size_t) : bn_sub_eq_len_st t aLen let bn_sub_eq_len_u (#t: limb_t) (aLen: size_t) : bn_sub_eq_len_st t aLen =

match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract

Hacl.Bignum.Addition.fst

val bn_sub_eq_len_u (#t: limb_t) (aLen: size_t) : bn_sub_eq_len_st t aLen

Hacl.Bignum.Addition.bn_sub_eq_len_u

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_sub_eq_len_st t aLen

Prims.Tot

val bn_add_eq_len_u (#t: limb_t) (aLen: size_t) : bn_add_eq_len_st t aLen

let bn_add_eq_len_u (#t:limb_t) (aLen:size_t) : bn_add_eq_len_st t aLen = match t with | U32 -> bn_add_eq_len_u32 aLen | U64 -> bn_add_eq_len_u64 aLen

val bn_add_eq_len_u (#t: limb_t) (aLen: size_t) : bn_add_eq_len_st t aLen let bn_add_eq_len_u (#t: limb_t) (aLen: size_t) : bn_add_eq_len_st t aLen =

match t with | U32 -> bn_add_eq_len_u32 aLen | U64 -> bn_add_eq_len_u64 aLen

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen inline_for_extraction noextract

Hacl.Bignum.Addition.fst

val bn_add_eq_len_u (#t: limb_t) (aLen: size_t) : bn_add_eq_len_st t aLen

Hacl.Bignum.Addition.bn_add_eq_len_u

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_add_eq_len_st t aLen

Prims.Tot

let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r))

let bn_sub_eq_len_st (t: limb_t) (aLen: size_t) =

a: lbignum t aLen -> b: lbignum t aLen -> res: lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r))

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract

Hacl.Bignum.Addition.fst

val bn_sub_eq_len_st : t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0

Hacl.Bignum.Addition.bn_sub_eq_len_st

t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0

Prims.Tot

let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r))

let bn_add_eq_len_st (t: limb_t) (aLen: size_t) =

a: lbignum t aLen -> b: lbignum t aLen -> res: lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r))

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract

Hacl.Bignum.Addition.fst

val bn_add_eq_len_st : t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0

Hacl.Bignum.Addition.bn_add_eq_len_st

t: Hacl.Bignum.Definitions.limb_t -> aLen: Lib.IntTypes.size_t -> Type0

FStar.HyperStack.ST.Stack

val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0

val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res =

let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then [@@ inline_let ]let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 else c0

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_sub

aLen: Lib.IntTypes.size_t -> a: Hacl.Bignum.Definitions.lbignum t aLen -> bLen: Lib.IntTypes.size_t{Lib.IntTypes.v bLen <= Lib.IntTypes.v aLen} -> b: Hacl.Bignum.Definitions.lbignum t bLen -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

FStar.HyperStack.ST.Stack

val bn_add: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

let bn_add #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let c0 = bn_add_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_add_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0

val bn_add: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_add #t aLen a bLen b res =

let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let c0 = bn_add_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then [@@ inline_let ]let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_add_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 else c0

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen inline_for_extraction noextract let bn_add_eq_len_u (#t:limb_t) (aLen:size_t) : bn_add_eq_len_st t aLen = match t with | U32 -> bn_add_eq_len_u32 aLen | U64 -> bn_add_eq_len_u64 aLen inline_for_extraction noextract val bn_add: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_add: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_add

aLen: Lib.IntTypes.size_t -> a: Hacl.Bignum.Definitions.lbignum t aLen -> bLen: Lib.IntTypes.size_t{Lib.IntTypes.v bLen <= Lib.IntTypes.v aLen} -> b: Hacl.Bignum.Definitions.lbignum t bLen -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

FStar.HyperStack.ST.Stack

val bn_add1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

let bn_add1 #t aLen a b1 res = let c0 = addcarry_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_add_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0

val bn_add1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_add1 #t aLen a b1 res =

let c0 = addcarry_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then [@@ inline_let ]let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_add_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 else c0

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_add_eq_len_u32 (aLen:size_t) : bn_add_eq_len_st U32 aLen = bn_add_eq_len aLen let bn_add_eq_len_u64 (aLen:size_t) : bn_add_eq_len_st U64 aLen = bn_add_eq_len aLen inline_for_extraction noextract let bn_add_eq_len_u (#t:limb_t) (aLen:size_t) : bn_add_eq_len_st t aLen = match t with | U32 -> bn_add_eq_len_u32 aLen | U64 -> bn_add_eq_len_u64 aLen inline_for_extraction noextract val bn_add: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_add #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let c0 = bn_add_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_add_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_add1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_add1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_add1

aLen: Lib.IntTypes.size_t{0 < Lib.IntTypes.v aLen} -> a: Hacl.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Bignum.Definitions.limb t -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

FStar.HyperStack.ST.Stack

val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0

val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res =

let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then [@@ inline_let ]let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 else c0

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_sub1

aLen: Lib.IntTypes.size_t{0 < Lib.IntTypes.v aLen} -> a: Hacl.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Bignum.Definitions.limb t -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

Prims.Tot

val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen

let bn_add_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen let bn_add_eq_len #t aLen a b res =

push_frame (); let c = create 1ul (uint #t 0) in [@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in [@@ inline_let ]let footprint (i: size_nat{i <= v aLen}) : GTot (l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@@ inline_let ]let spec h = S.bn_add_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1); let res = c.(0ul) in pop_frame (); res

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_add_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_add_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen

Hacl.Bignum.Addition.fst

val bn_add_eq_len: #t:limb_t -> aLen:size_t -> bn_add_eq_len_st t aLen

Hacl.Bignum.Addition.bn_add_eq_len

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_add_eq_len_st t aLen

Prims.Tot

val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen

let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res =

push_frame (); let c = create 1ul (uint #t 0) in [@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in [@@ inline_let ]let footprint (i: size_nat{i <= v aLen}) : GTot (l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@@ inline_let ]let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1); let res = c.(0ul) in pop_frame (); res

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen

Hacl.Bignum.Addition.fst

val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen

Hacl.Bignum.Addition.bn_sub_eq_len

aLen: Lib.IntTypes.size_t -> Hacl.Bignum.Addition.bn_sub_eq_len_st t aLen

FStar.HyperStack.ST.Stack

val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res =

push_frame (); let c = create 1ul c_in in [@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in [@@ inline_let ]let footprint (i: size_nat{i <= v aLen}) : GTot (l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@@ inline_let ]let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1); let res = c.(0ul) in pop_frame (); res

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_sub_carry

aLen: Lib.IntTypes.size_t -> a: Hacl.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

FStar.HyperStack.ST.Stack

val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

let bn_add_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res

val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_add_carry #t aLen a c_in res =

push_frame (); let c = create 1ul c_in in [@@ inline_let ]let refl h i = LSeq.index (as_seq h c) 0 in [@@ inline_let ]let footprint (i: size_nat{i <= v aLen}) : GTot (l: B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@@ inline_let ]let spec h = S.bn_add_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- addcarry_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1); let res = c.(0ul) in pop_frame (); res

module Hacl.Bignum.Addition open FStar.HyperStack open FStar.HyperStack.ST open FStar.Mul open Hacl.Bignum.Definitions open Hacl.Bignum.Base open Hacl.Impl.Lib open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module B = LowStar.Buffer module S = Hacl.Spec.Bignum.Addition module LSeq = Lib.Sequence module SL = Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract val bn_sub_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r)) let bn_sub_carry #t aLen a c_in res = push_frame (); let c = create 1ul c_in in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_carry_f (as_seq h a) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 (uint #t 0) res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1 ); let res = c.(0ul) in pop_frame (); res inline_for_extraction noextract let bn_sub_eq_len_st (t:limb_t) (aLen:size_t) = a:lbignum t aLen -> b:lbignum t aLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ eq_or_disjoint a b /\ eq_or_disjoint a res /\ eq_or_disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = SL.generate_elems (v aLen) (v aLen) (S.bn_sub_f (as_seq h0 a) (as_seq h0 b)) (uint #t 0) in c_out == c /\ as_seq h1 res == r)) inline_for_extraction noextract val bn_sub_eq_len: #t:limb_t -> aLen:size_t -> bn_sub_eq_len_st t aLen let bn_sub_eq_len #t aLen a b res = push_frame (); let c = create 1ul (uint #t 0) in [@inline_let] let refl h i = LSeq.index (as_seq h c) 0 in [@inline_let] let footprint (i:size_nat{i <= v aLen}) : GTot (l:B.loc{B.loc_disjoint l (loc res) /\ B.address_liveness_insensitive_locs `B.loc_includes` l}) = loc c in [@inline_let] let spec h = S.bn_sub_f (as_seq h a) (as_seq h b) in let h0 = ST.get () in fill_elems4 h0 aLen res refl footprint spec (fun i -> let h1 = ST.get () in let t1 = a.(i) in let t2 = b.(i) in let res_i = sub res i 1ul in c.(0ul) <- subborrow_st c.(0ul) t1 t2 res_i; lemma_eq_disjoint aLen aLen 1ul res a c i h0 h1; lemma_eq_disjoint aLen aLen 1ul res b c i h0 h1 ); let res = c.(0ul) in pop_frame (); res let bn_sub_eq_len_u32 (aLen:size_t) : bn_sub_eq_len_st U32 aLen = bn_sub_eq_len aLen let bn_sub_eq_len_u64 (aLen:size_t) : bn_sub_eq_len_st U64 aLen = bn_sub_eq_len aLen inline_for_extraction noextract let bn_sub_eq_len_u (#t:limb_t) (aLen:size_t) : bn_sub_eq_len_st t aLen = match t with | U32 -> bn_sub_eq_len_u32 aLen | U64 -> bn_sub_eq_len_u64 aLen inline_for_extraction noextract val bn_sub: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> bLen:size_t{v bLen <= v aLen} -> b:lbignum t bLen -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h b /\ live h res /\ disjoint a b /\ eq_or_disjoint a res /\ disjoint b res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub (as_seq h0 a) (as_seq h0 b) in c_out == c /\ as_seq h1 res == r)) let bn_sub #t aLen a bLen b res = let h0 = ST.get () in let a0 = sub a 0ul bLen in let res0 = sub res 0ul bLen in let h1 = ST.get () in let c0 = bn_sub_eq_len bLen a0 b res0 in let h1 = ST.get () in if bLen <. aLen then begin [@inline_let] let rLen = aLen -! bLen in let a1 = sub a bLen rLen in let res1 = sub res bLen rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h2 = ST.get () in LSeq.lemma_concat2 (v bLen) (as_seq h1 res0) (v rLen) (as_seq h2 res1) (as_seq h2 res); c1 end else c0 inline_for_extraction noextract val bn_sub1: #t:limb_t -> aLen:size_t{0 < v aLen} -> a:lbignum t aLen -> b1:limb t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_sub1 (as_seq h0 a) b1 in c_out == c /\ as_seq h1 res == r)) let bn_sub1 #t aLen a b1 res = let c0 = subborrow_st (uint #t 0) a.(0ul) b1 (sub res 0ul 1ul) in let h0 = ST.get () in LSeq.eq_intro (LSeq.sub (as_seq h0 res) 0 1) (LSeq.create 1 (LSeq.index (as_seq h0 res) 0)); if 1ul <. aLen then begin [@inline_let] let rLen = aLen -! 1ul in let a1 = sub a 1ul rLen in let res1 = sub res 1ul rLen in let c1 = bn_sub_carry rLen a1 c0 res1 in let h = ST.get () in LSeq.lemma_concat2 1 (LSeq.sub (as_seq h0 res) 0 1) (v rLen) (as_seq h res1) (as_seq h res); c1 end else c0 inline_for_extraction noextract val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.fst

val bn_add_carry: #t:limb_t -> aLen:size_t -> a:lbignum t aLen -> c_in:carry t -> res:lbignum t aLen -> Stack (carry t) (requires fun h -> live h a /\ live h res /\ eq_or_disjoint a res) (ensures fun h0 c_out h1 -> modifies (loc res) h0 h1 /\ (let c, r = S.bn_add_carry (as_seq h0 a) c_in in c_out == c /\ as_seq h1 res == r))

Hacl.Bignum.Addition.bn_add_carry

aLen: Lib.IntTypes.size_t -> a: Hacl.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> res: Hacl.Bignum.Definitions.lbignum t aLen -> FStar.HyperStack.ST.Stack (Hacl.Spec.Bignum.Base.carry t)

Prims.Tot

val varray (#elt: Type) (a: array elt) : Tot vprop

let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm

val varray (#elt: Type) (a: array elt) : Tot vprop let varray (#elt: Type) (a: array elt) : Tot vprop =

varrayp a P.full_perm

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt)

Steel.Array.fsti

val varray (#elt: Type) (a: array elt) : Tot vprop

Steel.Array.varray

a: Steel.ST.Array.array elt -> Steel.Effect.Common.vprop

Prims.Tot

val varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop

let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; })

val varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop =

VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p })

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm)

Steel.Array.fsti

val varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop

Steel.Array.varrayp

a: Steel.ST.Array.array elt -> p: Steel.FractionalPermission.perm -> Steel.Effect.Common.vprop

Prims.GTot

val asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True)}) : GTot (Seq.lseq elt (length a))

let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a)

val asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True)}) : GTot (Seq.lseq elt (length a)) let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True)}) : GTot (Seq.lseq elt (length a)) =

h (varray a)

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) })

Steel.Array.fsti

val asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True)}) : GTot (Seq.lseq elt (length a))

Steel.Array.asel

a: Steel.ST.Array.array elt -> h: Steel.Effect.Common.rmem vp { FStar.Tactics.Effect.with_tactic Steel.Effect.Common.selector_tactic (Steel.Effect.Common.can_be_split vp (Steel.Array.varray a) /\ Prims.l_True) } -> Prims.GTot (FStar.Seq.Properties.lseq elt (Steel.ST.Array.length a))

Prims.GTot

val aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True)}) : GTot (Seq.lseq elt (length a))

let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p)

val aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True)}) : GTot (Seq.lseq elt (length a)) let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True)}) : GTot (Seq.lseq elt (length a)) =

h (varrayp a p)

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) })

Steel.Array.fsti

val aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp {FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True)}) : GTot (Seq.lseq elt (length a))

Steel.Array.aselp

a: Steel.ST.Array.array elt -> p: Steel.FractionalPermission.perm -> h: Steel.Effect.Common.rmem vp { FStar.Tactics.Effect.with_tactic Steel.Effect.Common.selector_tactic (Steel.Effect.Common.can_be_split vp (Steel.Array.varrayp a p) /\ Prims.l_True) } -> Prims.GTot (FStar.Seq.Properties.lseq elt (Steel.ST.Array.length a))

Steel.Effect.Atomic.SteelGhost

val elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h)

let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _

val elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h) =

elim_varrayp _ _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h

Steel.Array.fsti

val elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h)

Steel.Array.elim_varray

a: Steel.ST.Array.array elt -> Steel.Effect.Atomic.SteelGhost (FStar.Ghost.erased (FStar.Seq.Base.seq elt))

Steel.Effect.Atomic.SteelGhost

val intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s)

let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _

val intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s) =

intro_varrayp _ _ _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s

Steel.Array.fsti

val intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s)

Steel.Array.intro_varray

a: Steel.ST.Array.array elt -> s: FStar.Seq.Base.seq elt -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.SteelT

val intro_fits_ptrdiff64: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp)

let intro_fits_ptrdiff64 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp) = A.intro_fits_ptrdiff64 ()

val intro_fits_ptrdiff64: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp) let intro_fits_ptrdiff64 (_: unit) : SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp) =

A.intro_fits_ptrdiff64 ()

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res /// An introduction function for the fits_u32 predicate. /// It will be natively extracted to static_assert (UINT32_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) = A.intro_fits_u32 () /// An introduction function for the fits_u64 predicate. /// It will be natively extracted to static_assert (UINT64_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u64 (_:unit) : SteelT (squash (US.fits_u64)) emp (fun _ -> emp) = A.intro_fits_u64 () /// Determining whether int32 values fit in a ptrdiff /// It will be natively extracted to static_assert (INT32_MAX <= PTRDIFF_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_ptrdiff32 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp) = A.intro_fits_ptrdiff32 () /// Determining whether int64 values fit in a ptrdiff /// It will be natively extracted to static_assert (INT64_MAX <= PTRDIFF_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_ptrdiff64 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 64)))

Steel.Array.fsti

val intro_fits_ptrdiff64: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp)

Steel.Array.intro_fits_ptrdiff64

_: Prims.unit -> Steel.Effect.SteelT (Prims.squash (FStar.PtrdiffT.fits (FStar.Int.max_int 64)))

Steel.Effect.SteelT

val intro_fits_u64: unit -> SteelT (squash (US.fits_u64)) emp (fun _ -> emp)

let intro_fits_u64 (_:unit) : SteelT (squash (US.fits_u64)) emp (fun _ -> emp) = A.intro_fits_u64 ()

val intro_fits_u64: unit -> SteelT (squash (US.fits_u64)) emp (fun _ -> emp) let intro_fits_u64 (_: unit) : SteelT (squash (US.fits_u64)) emp (fun _ -> emp) =

A.intro_fits_u64 ()

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res /// An introduction function for the fits_u32 predicate. /// It will be natively extracted to static_assert (UINT32_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) = A.intro_fits_u32 () /// An introduction function for the fits_u64 predicate. /// It will be natively extracted to static_assert (UINT64_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u64 (_:unit) : SteelT (squash (US.fits_u64))

Steel.Array.fsti

val intro_fits_u64: unit -> SteelT (squash (US.fits_u64)) emp (fun _ -> emp)

Steel.Array.intro_fits_u64

_: Prims.unit -> Steel.Effect.SteelT (Prims.squash FStar.SizeT.fits_u64)

Steel.Effect.SteelT

val intro_fits_ptrdiff32: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp)

let intro_fits_ptrdiff32 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp) = A.intro_fits_ptrdiff32 ()

val intro_fits_ptrdiff32: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp) let intro_fits_ptrdiff32 (_: unit) : SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp) =

A.intro_fits_ptrdiff32 ()

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res /// An introduction function for the fits_u32 predicate. /// It will be natively extracted to static_assert (UINT32_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) = A.intro_fits_u32 () /// An introduction function for the fits_u64 predicate. /// It will be natively extracted to static_assert (UINT64_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u64 (_:unit) : SteelT (squash (US.fits_u64)) emp (fun _ -> emp) = A.intro_fits_u64 () /// Determining whether int32 values fit in a ptrdiff /// It will be natively extracted to static_assert (INT32_MAX <= PTRDIFF_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_ptrdiff32 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 32)))

Steel.Array.fsti

val intro_fits_ptrdiff32: unit -> SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp)

Steel.Array.intro_fits_ptrdiff32

_: Prims.unit -> Steel.Effect.SteelT (Prims.squash (FStar.PtrdiffT.fits (FStar.Int.max_int 32)))

Steel.Effect.SteelT

val intro_fits_u32: unit -> SteelT (squash (US.fits_u32)) emp (fun _ -> emp)

let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) = A.intro_fits_u32 ()

val intro_fits_u32: unit -> SteelT (squash (US.fits_u32)) emp (fun _ -> emp) let intro_fits_u32 (_: unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) =

A.intro_fits_u32 ()

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res /// An introduction function for the fits_u32 predicate. /// It will be natively extracted to static_assert (UINT32_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32))

Steel.Array.fsti

val intro_fits_u32: unit -> SteelT (squash (US.fits_u32)) emp (fun _ -> emp)

Steel.Array.intro_fits_u32

_: Prims.unit -> Steel.Effect.SteelT (Prims.squash FStar.SizeT.fits_u32)

Steel.Effect.Atomic.SteelGhost

val varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null)

let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _

val varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null) let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null) =

let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null

Steel.Array.fsti

val varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null)

Steel.Array.varrayp_not_null

a: Steel.ST.Array.array elt -> p: Steel.FractionalPermission.perm -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.Steel

val malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x)

let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res

val malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x) let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x) =

let res = A.malloc x n in intro_varray res _; return res

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x

Steel.Array.fsti

val malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x)

Steel.Array.malloc

x: elt -> n: FStar.SizeT.t -> Steel.Effect.Steel (Steel.ST.Array.array elt)

Steel.Effect.Atomic.SteelGhost

val share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> (varrayp a p1) `star` (varrayp a p2)) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h)

let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _

val share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> (varrayp a p1) `star` (varrayp a p2)) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h) let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> (varrayp a p1) `star` (varrayp a p2)) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h) =

let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h

Steel.Array.fsti

val share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> (varrayp a p1) `star` (varrayp a p2)) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h)

Steel.Array.share

a: Steel.ST.Array.array elt -> p: Steel.FractionalPermission.perm -> p1: Steel.FractionalPermission.perm -> p2: Steel.FractionalPermission.perm -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.Atomic.SteelGhost

val gather (#opened: _) (#elt: Type) (a: array elt) (p1 p2: P.perm) : SteelGhost unit opened ((varrayp a p1) `star` (varrayp a p2)) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h)

let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _

val gather (#opened: _) (#elt: Type) (a: array elt) (p1 p2: P.perm) : SteelGhost unit opened ((varrayp a p1) `star` (varrayp a p2)) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h) let gather (#opened: _) (#elt: Type) (a: array elt) (p1 p2: P.perm) : SteelGhost unit opened ((varrayp a p1) `star` (varrayp a p2)) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h) =

let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h

Steel.Array.fsti

val gather (#opened: _) (#elt: Type) (a: array elt) (p1 p2: P.perm) : SteelGhost unit opened ((varrayp a p1) `star` (varrayp a p2)) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h)

Steel.Array.gather

a: Steel.ST.Array.array elt -> p1: Steel.FractionalPermission.perm -> p2: Steel.FractionalPermission.perm -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.Steel

val index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i))

let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res

val index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i)) let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i)) =

let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i)

Steel.Array.fsti

val index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i))

Steel.Array.index

a: Steel.ST.Array.array t -> i: FStar.SizeT.t -> Steel.Effect.Steel t

Steel.Effect.Atomic.SteelGhost

val ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h))

let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _

val ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h)) let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h)) =

let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h

Steel.Array.fsti

val ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h))

Steel.Array.ghost_join

a1: Steel.ST.Array.array elt -> a2: Steel.ST.Array.array elt -> sq: Prims.squash (Steel.ST.Array.adjacent a1 a2) -> Steel.Effect.Atomic.SteelGhost Prims.unit

Steel.Effect.Steel

val upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v)

let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _

val upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v) let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v) =

let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v

Steel.Array.fsti

val upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v)

Steel.Array.upd

a: Steel.ST.Array.array t -> i: FStar.SizeT.t -> v: t -> Steel.Effect.Steel Prims.unit

Steel.Effect.Atomic.SteelAtomicBase

val join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h))

let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res

val join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h)) let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h)) =

let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h

Steel.Array.fsti

val join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable ((varrayp a1 p) `star` (varrayp a2 p)) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == (aselp a1 p h) `Seq.append` (aselp a2 p h))

Steel.Array.join

a1: Steel.ST.Array.array elt -> a2: FStar.Ghost.erased (Steel.ST.Array.array elt) -> Steel.Effect.Atomic.SteelAtomicBase (Steel.ST.Array.array elt)

Steel.Effect.Steel

val memcpy (#t: _) (#p0: P.perm) (a0 a1: array t) (i: US.t) : Steel unit ((varrayp a0 p0) `star` (varray a1)) (fun _ -> (varrayp a0 p0) `star` (varray a1)) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1 )

let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _

val memcpy (#t: _) (#p0: P.perm) (a0 a1: array t) (i: US.t) : Steel unit ((varrayp a0 p0) `star` (varray a1)) (fun _ -> (varrayp a0 p0) `star` (varray a1)) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1 ) let memcpy (#t: _) (#p0: P.perm) (a0 a1: array t) (i: US.t) : Steel unit ((varrayp a0 p0) `star` (varray a1)) (fun _ -> (varrayp a0 p0) `star` (varray a1)) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1 ) =

let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\

Steel.Array.fsti

val memcpy (#t: _) (#p0: P.perm) (a0 a1: array t) (i: US.t) : Steel unit ((varrayp a0 p0) `star` (varray a1)) (fun _ -> (varrayp a0 p0) `star` (varray a1)) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1 )

Steel.Array.memcpy

a0: Steel.ST.Array.array t -> a1: Steel.ST.Array.array t -> i: FStar.SizeT.t -> Steel.Effect.Steel Prims.unit

Steel.Effect.Steel

val ptrdiff (#a: Type) (#p1 #p2: P.perm) (arr1 arr2: array a) : Steel UP.t ((varrayp arr1 p1) `star` (varrayp arr2 p2)) (fun _ -> (varrayp arr1 p1) `star` (varrayp arr2 p2)) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2))

let ptrdiff (#a: Type) (#p1 #p2:P.perm) (arr1 arr2: array a) : Steel UP.t (varrayp arr1 p1 `star` varrayp arr2 p2) (fun _ -> varrayp arr1 p1 `star` varrayp arr2 p2) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2) ) = let _ = elim_varrayp arr1 p1 in let _ = elim_varrayp arr2 p2 in let res = A.ptrdiff arr1 arr2 in intro_varrayp arr1 _ _; intro_varrayp arr2 _ _; return res

val ptrdiff (#a: Type) (#p1 #p2: P.perm) (arr1 arr2: array a) : Steel UP.t ((varrayp arr1 p1) `star` (varrayp arr2 p2)) (fun _ -> (varrayp arr1 p1) `star` (varrayp arr2 p2)) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2)) let ptrdiff (#a: Type) (#p1 #p2: P.perm) (arr1 arr2: array a) : Steel UP.t ((varrayp arr1 p1) `star` (varrayp arr2 p2)) (fun _ -> (varrayp arr1 p1) `star` (varrayp arr2 p2)) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2)) =

let _ = elim_varrayp arr1 p1 in let _ = elim_varrayp arr2 p2 in let res = A.ptrdiff arr1 arr2 in intro_varrayp arr1 _ _; intro_varrayp arr2 _ _; return res

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res /// An introduction function for the fits_u32 predicate. /// It will be natively extracted to static_assert (UINT32_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u32 (_:unit) : SteelT (squash (US.fits_u32)) emp (fun _ -> emp) = A.intro_fits_u32 () /// An introduction function for the fits_u64 predicate. /// It will be natively extracted to static_assert (UINT64_MAX <= SIZE_T_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_u64 (_:unit) : SteelT (squash (US.fits_u64)) emp (fun _ -> emp) = A.intro_fits_u64 () /// Determining whether int32 values fit in a ptrdiff /// It will be natively extracted to static_assert (INT32_MAX <= PTRDIFF_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_ptrdiff32 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 32))) emp (fun _ -> emp) = A.intro_fits_ptrdiff32 () /// Determining whether int64 values fit in a ptrdiff /// It will be natively extracted to static_assert (INT64_MAX <= PTRDIFF_MAX) by krml inline_for_extraction [@@noextract_to "krml"] let intro_fits_ptrdiff64 (_:unit) : SteelT (squash (UP.fits (FStar.Int.max_int 64))) emp (fun _ -> emp) = A.intro_fits_ptrdiff64 () inline_for_extraction [@@noextract_to "krml"] let ptrdiff (#a: Type) (#p1 #p2:P.perm) (arr1 arr2: array a) : Steel UP.t (varrayp arr1 p1 `star` varrayp arr2 p2) (fun _ -> varrayp arr1 p1 `star` varrayp arr2 p2) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2)

Steel.Array.fsti

val ptrdiff (#a: Type) (#p1 #p2: P.perm) (arr1 arr2: array a) : Steel UP.t ((varrayp arr1 p1) `star` (varrayp arr2 p2)) (fun _ -> (varrayp arr1 p1) `star` (varrayp arr2 p2)) (requires fun _ -> base (ptr_of arr1) == base (ptr_of arr2) /\ UP.fits (offset (ptr_of arr1) - offset (ptr_of arr2))) (ensures fun h0 r h1 -> aselp arr1 p1 h1 == aselp arr1 p1 h0 /\ aselp arr2 p2 h1 == aselp arr2 p2 h0 /\ UP.v r == offset (ptr_of arr1) - offset (ptr_of arr2))

Steel.Array.ptrdiff

arr1: Steel.ST.Array.array a -> arr2: Steel.ST.Array.array a -> Steel.Effect.Steel FStar.PtrdiffT.t

Steel.Effect.Steel

val compare (#t: eqtype) (#p0 #p1: P.perm) (a0 a1: array t) (l: US.t{length a0 == length a1 /\ US.v l == length a0}) : Steel bool ((varrayp a0 p0) `star` (varrayp a1 p1)) (fun _ -> (varrayp a0 p0) `star` (varrayp a1 p1)) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1))

let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) = let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res

val compare (#t: eqtype) (#p0 #p1: P.perm) (a0 a1: array t) (l: US.t{length a0 == length a1 /\ US.v l == length a0}) : Steel bool ((varrayp a0 p0) `star` (varrayp a1 p1)) (fun _ -> (varrayp a0 p0) `star` (varrayp a1 p1)) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) let compare (#t: eqtype) (#p0 #p1: P.perm) (a0 a1: array t) (l: US.t{length a0 == length a1 /\ US.v l == length a0}) : Steel bool ((varrayp a0 p0) `star` (varrayp a1 p1)) (fun _ -> (varrayp a0 p0) `star` (varrayp a1 p1)) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1)) =

let _ = elim_varrayp a0 _ in let _ = elim_varrayp a1 _ in let res = A.compare a0 a1 l in intro_varrayp a0 _ _; intro_varrayp a1 _ _; return res

(* Copyright 2020, 2021, 2022 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. *) module Steel.Array open Steel.Memory open Steel.Effect.Atomic open Steel.Effect include Steel.ST.Array /// C arrays of universe 0 elements, with selectors. /// Non-selector style universe 0 arrays are defined in Steel.ST, but /// we want to transparently reuse the corresponding operations in /// Steel, so we need to bring in the lift from Steel.ST to Steel, /// defined in Steel.ST.Coercions. module STC = Steel.ST.Coercions module P = Steel.FractionalPermission module US = FStar.SizeT module UP = FStar.PtrdiffT module A = Steel.ST.Array /// A selector version /// Separation logic predicate indicating the validity of the array in the current memory, p is the fractional permission on the array val varrayp_hp (#elt: Type0) (a: array elt) (p: P.perm) : Tot (slprop u#1) /// Selector for Steel arrays. It returns the contents in memory of the array val varrayp_sel (#elt: Type) (a: array elt) (p: P.perm) : Tot (selector (Seq.lseq elt (length a)) (varrayp_hp a p)) /// Combining the elements above to create an array vprop [@__steel_reduce__] // for t_of let varrayp (#elt: Type) (a: array elt) (p: P.perm) : Tot vprop = VUnit ({ hp = varrayp_hp a p; t = _; sel = varrayp_sel a p; }) /// A wrapper to access an array selector more easily. /// Ensuring that the corresponding array vprop is in the context is done by /// calling a variant of the framing tactic, as defined in Steel.Effect.Common [@@ __steel_reduce__] let aselp (#elt: Type) (#vp: vprop) (a: array elt) (p: P.perm) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varrayp a p) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varrayp a p) [@@__steel_reduce__; __reduce__] let varray (#elt: Type) (a: array elt) : Tot vprop = varrayp a P.full_perm [@@ __steel_reduce__] let asel (#elt: Type) (#vp: vprop) (a: array elt) (h: rmem vp { FStar.Tactics.with_tactic selector_tactic (can_be_split vp (varray a) /\ True) }) : GTot (Seq.lseq elt (length a)) = h (varray a) /// Converting a `pts_to` to a `varrayp` val intro_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a p s) (fun _ -> varrayp a p) (fun _ -> True) (fun _ _ h' -> aselp a p h' == s ) let intro_varray (#opened: _) (#elt: Type) (a: array elt) (s: Seq.seq elt) : SteelGhost unit opened (pts_to a P.full_perm s) (fun _ -> varray a) (fun _ -> True) (fun _ _ h' -> asel a h' == s ) = intro_varrayp _ _ _ /// Converting a `varrayp` into a `pts_to` val elim_varrayp (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varrayp a p) (fun res -> pts_to a p res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == aselp a p h ) let elim_varray (#opened: _) (#elt: Type) (a: array elt) : SteelGhost (Ghost.erased (Seq.seq elt)) opened (varray a) (fun res -> pts_to a P.full_perm res) (fun _ -> True) (fun h res _ -> Ghost.reveal res == asel a h ) = elim_varrayp _ _ let varrayp_not_null (#opened: _) (#elt: Type) (a: array elt) (p: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p) (fun _ -> True) (fun h _ h' -> aselp a p h' == aselp a p h /\ a =!= null ) = let _ = elim_varrayp a p in pts_to_not_null a _; intro_varrayp a p _ /// Allocating a new array of size n, where each cell is initialized /// with value x. We define the non-selector version of this operation /// (and others) with a _pt suffix in the name. inline_for_extraction [@@noextract_to "krml"] let malloc (#elt: Type) (x: elt) (n: US.t) : Steel (array elt) emp (fun a -> varray a) (fun _ -> True) (fun _ a h' -> length a == US.v n /\ is_full_array a /\ asel a h' == Seq.create (US.v n) x ) = let res = A.malloc x n in intro_varray res _; return res /// Freeing a full array. inline_for_extraction [@@ noextract_to "krml"; warn_on_use "Steel.Array.free is currently unsound in the presence of zero-size subarrays, have you collected them all?"] let free (#elt: Type) (a: array elt) : Steel unit (varray a) (fun _ -> emp) (fun _ -> is_full_array a ) (fun _ _ _ -> True) = let _ = elim_varray a in A.free a /// Sharing and gathering permissions on an array. Those only /// manipulate permissions, so they are nothing more than stateful /// lemmas. inline_for_extraction // FIXME: F* bug. This attribute is not necessary here, but if removed, F* complains about duplicate declaration and definition let share (#opened: _) (#elt: Type) (a: array elt) (p p1 p2: P.perm) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp a p1 `star` varrayp a p2) (fun _ -> p == p1 `P.sum_perm` p2) (fun h _ h' -> aselp a p1 h' == aselp a p h /\ aselp a p2 h' == aselp a p h ) = let _ = elim_varrayp a p in A.share a p p1 p2; intro_varrayp a p1 _; intro_varrayp a p2 _ inline_for_extraction // same here let gather (#opened: _) (#elt: Type) (a: array elt) (p1: P.perm) (p2: P.perm) : SteelGhost unit opened (varrayp a p1 `star` varrayp a p2) (fun _ -> varrayp a (p1 `P.sum_perm` p2)) (fun _ -> True) (fun h _ h' -> aselp a (p1 `P.sum_perm` p2) h' == aselp a p1 h /\ aselp a (p1 `P.sum_perm` p2) h' == aselp a p2 h ) = let _ = elim_varrayp a p1 in let _ = elim_varrayp a p2 in A.gather a p1 p2; intro_varrayp a _ _ /// Reading the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let index (#t: Type) (#p: P.perm) (a: array t) (i: US.t) : Steel t (varrayp a p) (fun _ -> varrayp a p) (fun _ -> US.v i < length a) (fun h res h' -> let s = aselp a p h in aselp a p h' == s /\ US.v i < Seq.length s /\ res == Seq.index s (US.v i) ) = let _ = elim_varrayp a p in let res = A.index a i in intro_varrayp a _ _; return res /// Writing the value v at the i-th element of an array a. /// TODO: we should also provide an atomic version for small types. inline_for_extraction [@@noextract_to "krml"] let upd (#t: Type) (a: array t) (i: US.t) (v: t) : Steel unit (varray a) (fun _ -> varray a) (fun _ -> US.v i < length a) (fun h _ h' -> US.v i < length a /\ asel a h' == Seq.upd (asel a h) (US.v i) v ) = let s = elim_varray a in A.pts_to_length a _; A.upd a i v; intro_varray a _ /// Spatial merging of two arrays, expressed in terms of `merge`. inline_for_extraction // same as above let ghost_join (#opened: _) (#elt: Type) (#p: P.perm) (a1 a2: array elt) (sq: squash (adjacent a1 a2)) : SteelGhost unit opened (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp (merge a1 a2) p) (fun _ -> True) (fun h _ h' -> aselp (merge a1 a2) p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 p in let _ = elim_varrayp a2 p in A.ghost_join a1 a2 (); intro_varrayp _ _ _ /// Spatial merging, combining the use of `merge` and the call to the /// stateful lemma. Since the only operations are calls to stateful /// lemmas and pure computations, the overall computation is atomic /// and unobservable, so can be used anywhere in atomic contexts. By /// virtue of the length being ghost, Karamel will extract this to /// "let res = a1" inline_for_extraction // this will extract to "let res = a1" [@@noextract_to "krml"] let join (#opened: _) (#elt: Type) (#p: P.perm) (a1: array elt) (a2: Ghost.erased (array elt)) : SteelAtomicBase (array elt) false opened Unobservable (varrayp a1 p `star` varrayp a2 p) (fun res -> varrayp res p) (fun _ -> adjacent a1 a2) (fun h res h' -> merge_into a1 a2 res /\ aselp res p h' == aselp a1 p h `Seq.append` aselp a2 p h ) = let _ = elim_varrayp a1 _ in let _ = elim_varrayp a2 _ in let res = A.join a1 a2 in intro_varrayp res _ _; return res /// Splitting an array a at offset i, as a stateful lemma expressed in /// terms of split_l, split_r. In the non-selector case, this stateful /// lemma returns a proof that offset i is in bounds of the value /// sequence, which is needed to typecheck the post-resource. inline_for_extraction // same as above let ghost_split (#opened: _) (#elt: Type) (#p: P.perm) (a: array elt) (i: US.t { US.v i <= length a }) : SteelGhost unit opened (varrayp a p) (fun _ -> varrayp (split_l a i) p `star` varrayp (split_r a i) p) (fun _ -> True) (fun h _ h' -> let x = aselp a p h in let xl = Seq.slice x 0 (US.v i) in let xr = Seq.slice x (US.v i) (Seq.length x) in aselp (split_l a i) p h' == xl /\ aselp (split_r a i) p h' == xr /\ x == Seq.append xl xr ) = let _ = elim_varrayp a _ in A.ghost_split a i; intro_varrayp (split_l a i) _ _; intro_varrayp (split_r a i) _ _ /// NOTE: we could implement a SteelAtomicBase Unobservable "split" /// operation, just like "join", but we don't want it to return a pair /// of arrays. For now we settle on explicit use of split_l, split_r. /// Copies the contents of a0 to a1 inline_for_extraction let memcpy (#t:_) (#p0:P.perm) (a0 a1:array t) (i:US.t) : Steel unit (varrayp a0 p0 `star` varray a1) (fun _ -> varrayp a0 p0 `star` varray a1) (requires fun _ -> US.v i == length a0 /\ length a0 == length a1) (ensures fun h0 _ h1 -> length a0 == length a1 /\ aselp a0 p0 h0 == aselp a0 p0 h1 /\ asel a1 h1 == aselp a0 p0 h1) = let _ = elim_varrayp a0 _ in let _ = elim_varray a1 in A.memcpy a0 a1 i; intro_varrayp a0 _ _; intro_varray a1 _ /// Decides whether the contents of a0 and a1 are equal inline_for_extraction let compare (#t:eqtype) (#p0 #p1:P.perm) (a0 a1:array t) (l:US.t { length a0 == length a1 /\ US.v l == length a0}) : Steel bool (varrayp a0 p0 `star` varrayp a1 p1) (fun _ -> varrayp a0 p0 `star` varrayp a1 p1) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\

Steel.Array.fsti

val compare (#t: eqtype) (#p0 #p1: P.perm) (a0 a1: array t) (l: US.t{length a0 == length a1 /\ US.v l == length a0}) : Steel bool ((varrayp a0 p0) `star` (varrayp a1 p1)) (fun _ -> (varrayp a0 p0) `star` (varrayp a1 p1)) (requires fun _ -> True) (ensures fun h0 b h1 -> aselp a0 p0 h0 == aselp a0 p0 h1 /\ aselp a1 p1 h0 == aselp a1 p1 h1 /\ b = (aselp a0 p0 h1 = aselp a1 p1 h1))

Steel.Array.compare

a0: Steel.ST.Array.array t -> a1: Steel.ST.Array.array t -> l: FStar.SizeT.t { Steel.ST.Array.length a0 == Steel.ST.Array.length a1 /\ FStar.SizeT.v l == Steel.ST.Array.length a0 } -> Steel.Effect.Steel Prims.bool

Prims.Tot

val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t

let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]

val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c =

subborrow c a.[ i ] b.[ i ]

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in

Hacl.Spec.Bignum.Addition.fst

val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t

Hacl.Spec.Bignum.Addition.bn_sub_f

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Lib.IntTypes.size_nat{i < aLen} -> c: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t

Prims.Tot

val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t

let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]

val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c =

addcarry c a.[ i ] b.[ i ]

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in

Hacl.Spec.Bignum.Addition.fst

val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t

Hacl.Spec.Bignum.Addition.bn_add_f

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Lib.IntTypes.size_nat{i < aLen} -> c: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t

Prims.Tot

val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)

let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in

val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in =

generate_elems aLen aLen (bn_add_carry_f a) c_in

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)

Hacl.Spec.Bignum.Addition.fst

val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)

Hacl.Spec.Bignum.Addition.bn_add_carry

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

Prims.Tot

val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t

let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0)

val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in =

addcarry c_in a.[ i ] (uint #t 0)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0

Hacl.Spec.Bignum.Addition.fst

val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t

Hacl.Spec.Bignum.Addition.bn_add_carry_f

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Lib.IntTypes.size_nat{i < aLen} -> c_in: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t

Prims.Tot

val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)

let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in

val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in =

generate_elems aLen aLen (bn_sub_carry_f a) c_in

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)

Hacl.Spec.Bignum.Addition.fst

val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen)

Hacl.Spec.Bignum.Addition.bn_sub_carry

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

Prims.Tot

val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t

let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0)

val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in =

subborrow c_in a.[ i ] (uint #t 0)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"

Hacl.Spec.Bignum.Addition.fst

val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t

Hacl.Spec.Bignum.Addition.bn_sub_carry_f

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> i: Lib.IntTypes.size_nat{i < aLen} -> c_in: Hacl.Spec.Bignum.Base.carry t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.limb t

Prims.Tot

val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)

let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b =

let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i]

Hacl.Spec.Bignum.Addition.fst

val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen)

Hacl.Spec.Bignum.Addition.bn_sub

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

FStar.Pervasives.Lemma

val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)

let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen

val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in =

let c_out, res = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)

Hacl.Spec.Bignum.Addition.fst

val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in)

Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_sub_carry a c_in in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * aLen) == Hacl.Spec.Bignum.Definitions.bn_v a - Lib.IntTypes.v c_in) <: Type0))

Prims.Tot

val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen

let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b =

let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i]

Hacl.Spec.Bignum.Addition.fst

val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen

Hacl.Spec.Bignum.Addition.bn_add

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

FStar.Pervasives.Lemma

val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)

let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen

val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in =

let c_out, res = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)

Hacl.Spec.Bignum.Addition.fst

val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in)

Hacl.Spec.Bignum.Addition.bn_add_carry_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_add_carry a c_in in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * aLen) + Hacl.Spec.Bignum.Definitions.bn_v res == Hacl.Spec.Bignum.Definitions.bn_v a + Lib.IntTypes.v c_in) <: Type0))

Prims.Tot

val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)

let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0

val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 =

let c0, r0 = subborrow (uint #t 0) a.[ 0 ] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

Hacl.Spec.Bignum.Addition.fst

val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)

Hacl.Spec.Bignum.Addition.bn_sub1

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

Prims.Tot

val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)

let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0

val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 =

let c0, r0 = addcarry (uint #t 0) a.[ 0 ] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0

Hacl.Spec.Bignum.Addition.fst

val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen)

Hacl.Spec.Bignum.Addition.bn_add1

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t -> Hacl.Spec.Bignum.Base.carry t * Hacl.Spec.Bignum.Definitions.lbignum t aLen

FStar.Pervasives.Lemma

val bn_sub_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_sub a b in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b)

let bn_sub_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_sub a b in if bLen = aLen then bn_sub_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in bn_sub_lemma_loop a0 b bLen; assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen); bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 end

val bn_sub_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_sub a b in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b) let bn_sub_lemma #t #aLen #bLen a b =

let pbits = bits t in let c, res = bn_sub a b in if bLen = aLen then bn_sub_lemma_loop a b aLen else let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in bn_sub_lemma_loop a0 b bLen; assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen); bn_sub_concat_lemma #t #aLen #bLen a b c0 res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)) let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i) val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) let rec bn_sub_lemma_loop #t #aLen a b i = let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1)); bn_sub_lemma_loop a b (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)); bn_sub_lemma_loop_step a b i (c1, res1); assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i); () end val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_sub_carry a1 c0 in bn_sub_carry_lemma a1 c0; assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0; (==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen); } val bn_sub_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_sub a b in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b)

Hacl.Spec.Bignum.Addition.fst

val bn_sub_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_sub a b in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b)

Hacl.Spec.Bignum.Addition.bn_sub_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_sub a b in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) == Hacl.Spec.Bignum.Definitions.bn_v a - Hacl.Spec.Bignum.Definitions.bn_v b) <: Type0))

FStar.Pervasives.Lemma

val bn_sub1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_sub1 a b1 in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1)

let bn_sub1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = subborrow (uint #t 0) a.[0] b1 in assert (v r0 - v c0 * pow2 pbits = v a.[0] - v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (bn_v #t #1 res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen); bn_sub_concat_lemma a b c0 res0 end

val bn_sub1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_sub1 a b1 in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1) let bn_sub1_lemma #t #aLen a b1 =

let pbits = bits t in let c0, r0 = subborrow (uint #t 0) a.[ 0 ] b1 in assert (v r0 - v c0 * pow2 pbits = v a.[ 0 ] - v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (bn_v #t #1 res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen); bn_sub_concat_lemma a b c0 res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)) let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i) val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) let rec bn_sub_lemma_loop #t #aLen a b i = let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1)); bn_sub_lemma_loop a b (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)); bn_sub_lemma_loop_step a b i (c1, res1); assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i); () end val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_sub_carry a1 c0 in bn_sub_carry_lemma a1 c0; assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0; (==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen); } val bn_sub_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_sub a b in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - bn_v b) let bn_sub_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_sub a b in if bLen = aLen then bn_sub_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_sub_f a0 b) (uint #t 0) in bn_sub_lemma_loop a0 b bLen; assert (bn_v #t #bLen res0 - v c0 * pow2 (pbits * bLen) == eval_ bLen a0 bLen - eval_ bLen b bLen); bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_sub1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_sub1 a b1 in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1)

Hacl.Spec.Bignum.Addition.fst

val bn_sub1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_sub1 a b1 in bn_v res - v c * pow2 (bits t * aLen) == bn_v a - v b1)

Hacl.Spec.Bignum.Addition.bn_sub1_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_sub1 a b1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * aLen) == Hacl.Spec.Bignum.Definitions.bn_v a - Lib.IntTypes.v b1) <: Type0))

FStar.Pervasives.Lemma

val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)

let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end

val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 =

let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[ 0 ] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[ 0 ] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)

Hacl.Spec.Bignum.Addition.fst

val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1)

Hacl.Spec.Bignum.Addition.bn_add1_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b1: Hacl.Spec.Bignum.Definitions.limb t -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_add1 a b1 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 b1) <: Type0))

FStar.Pervasives.Lemma

val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)

let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end

val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b =

let pbits = bits t in let c, res = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)

Hacl.Spec.Bignum.Addition.fst

val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b)

Hacl.Spec.Bignum.Addition.bn_add_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_add a b 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 + Hacl.Spec.Bignum.Definitions.bn_v b) <: Type0))

FStar.Pervasives.Lemma

val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)

let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end

val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i =

let pbits = bits t in let c, res:generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then (eq_generate_elems0 aLen i (bn_add_f a b) (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 b; ()) else let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); ()

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)

Hacl.Spec.Bignum.Addition.fst

val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)

Hacl.Spec.Bignum.Addition.bn_add_lemma_loop

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: 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.Addition.bn_add_f a b) (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 + Hacl.Spec.Bignum.Definitions.eval_ aLen b i) <: Type0))

FStar.Pervasives.Lemma

val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)

let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end

val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i =

let pbits = bits t in let c_out, res:generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then (eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); ()

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)

Hacl.Spec.Bignum.Addition.fst

val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)

Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> i: Prims.nat{i <= aLen} -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Lib.generate_elems aLen i (Hacl.Spec.Bignum.Addition.bn_add_carry_f a) c_in in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in let _ = _ in Lib.IntTypes.v c_out * 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 c_in) <: Type0))

FStar.Pervasives.Lemma

val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)

let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end

val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i =

let pbits = bits t in let c_out, res:generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then (eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); ()

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)

Hacl.Spec.Bignum.Addition.fst

val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)

Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> i: Prims.nat{i <= aLen} -> FStar.Pervasives.Lemma (ensures (let _ = Hacl.Spec.Lib.generate_elems aLen i (Hacl.Spec.Bignum.Addition.bn_sub_carry_f a) c_in in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in let _ = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) == Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Lib.IntTypes.v c_in) <: Type0))

FStar.Pervasives.Lemma

val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)

let rec bn_sub_lemma_loop #t #aLen a b i = let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1)); bn_sub_lemma_loop a b (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)); bn_sub_lemma_loop_step a b i (c1, res1); assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i); () end

val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) let rec bn_sub_lemma_loop #t #aLen a b i =

let c, res:generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in if i = 0 then (eq_generate_elems0 aLen i (bn_sub_f a b) (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 b; ()) else let c1, res1:generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1)); bn_sub_lemma_loop a b (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)); bn_sub_lemma_loop_step a b i (c1, res1); assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i); ()

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)) let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i) val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)

Hacl.Spec.Bignum.Addition.fst

val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)

Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: 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.Addition.bn_sub_f a b) (Lib.IntTypes.uint 0) in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in let _ = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) == Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Hacl.Spec.Bignum.Definitions.eval_ aLen b i) <: Type0))

FStar.Pervasives.Lemma

val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen)))

let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_sub_carry a1 c0 in bn_sub_carry_lemma a1 c0; assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0; (==) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen); }

val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen))) let bn_sub_concat_lemma #t #aLen #bLen a b c0 res0 =

let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_sub_carry a1 c0 in bn_sub_carry_lemma a1 c0; assert (bn_v res1 - v c1 * pow2 (pbits * (aLen - bLen)) == bn_v a1 - v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc ( == ) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; ( == ) { () } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 - v c0 + v c1 * pow2 (pbits * (aLen - bLen))); ( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) (v c0) } eval_ bLen a0 bLen - eval_ bLen b bLen + v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c1 * pow2 (pbits * (aLen - bLen))) - pow2 (pbits * bLen) * v c0; ( == ) { Math.Lemmas.distributivity_add_right (pow2 (pbits * bLen)) (bn_v a1) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + (pow2 (pbits * bLen) * v c1) * pow2 (pbits * (aLen - bLen)); ( == ) { (Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen))) } eval_ bLen a0 bLen - eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 + v c1 * pow2 (pbits * aLen); ( == ) { (bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen) } eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (pbits * aLen); }

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)) let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i) val bn_sub_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i) let rec bn_sub_lemma_loop #t #aLen a b i = let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_sub_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_sub_f a b) (uint #t 0) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_sub_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1)); bn_sub_lemma_loop a b (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1)); bn_sub_lemma_loop_step a b i (c1, res1); assert (bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i); () end val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen)))

Hacl.Spec.Bignum.Addition.fst

val bn_sub_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires bn_v #t #bLen res0 - v c0 * pow2 (bits t * bLen) == eval_ bLen (sub a 0 bLen) bLen - eval_ bLen b bLen) (ensures (let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen - eval_ bLen b bLen + v c1 * pow2 (bits t * aLen)))

Hacl.Spec.Bignum.Addition.bn_sub_concat_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> c0: Hacl.Spec.Bignum.Base.carry t -> res0: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> FStar.Pervasives.Lemma (requires Hacl.Spec.Bignum.Definitions.bn_v res0 - Lib.IntTypes.v c0 * Prims.pow2 (Lib.IntTypes.bits t * bLen) == Hacl.Spec.Bignum.Definitions.eval_ bLen (Lib.Sequence.sub a 0 bLen) bLen - Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen) (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_sub_carry (Lib.Sequence.sub a bLen (aLen - bLen)) c0 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in let res = Lib.Sequence.concat res0 res1 in Hacl.Spec.Bignum.Definitions.bn_v res == Hacl.Spec.Bignum.Definitions.eval_ aLen a aLen - Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen + Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * aLen)) <: Type0))

FStar.Pervasives.Lemma

val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))

let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); }

val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 =

let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc ( == ) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; ( == ) { () } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); ( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - (pow2 (pbits * bLen) * v c1) * pow2 (pbits * (aLen - bLen)); ( == ) { (Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); ( == ) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); ( == ) { (bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen) } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); }

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))

Hacl.Spec.Bignum.Addition.fst

val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen)))

Hacl.Spec.Bignum.Addition.bn_add_concat_lemma

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> c0: Hacl.Spec.Bignum.Base.carry t -> res0: Hacl.Spec.Bignum.Definitions.lbignum t bLen -> FStar.Pervasives.Lemma (requires Lib.IntTypes.v c0 * Prims.pow2 (Lib.IntTypes.bits t * bLen) + Hacl.Spec.Bignum.Definitions.bn_v res0 == Hacl.Spec.Bignum.Definitions.eval_ bLen (Lib.Sequence.sub a 0 bLen) bLen + Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen) (ensures (let _ = Hacl.Spec.Bignum.Addition.bn_add_carry (Lib.Sequence.sub a bLen (aLen - bLen)) c0 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in let res = Lib.Sequence.concat res0 res1 in Hacl.Spec.Bignum.Definitions.bn_v res == Hacl.Spec.Bignum.Definitions.eval_ aLen a aLen + Hacl.Spec.Bignum.Definitions.eval_ bLen b bLen - Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * aLen)) <: Type0))

FStar.Pervasives.Lemma

val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))

let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)

val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =

let pbits = bits t in let c_out, res = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[ i - 1 ] - v c1); calc ( == ) { bn_v #t #i res - v c * pow2 (pbits * i); ( == ) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { () } eval_ aLen a (i - 1) - v c_in + (v a.[ i - 1 ] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[ i - 1 ] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) + (v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))

Hacl.Spec.Bignum.Addition.fst

val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in))

Hacl.Spec.Bignum.Addition.bn_sub_carry_lemma_loop_step

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> i: Prims.pos{i <= aLen} -> c1_res1: Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t) (Hacl.Spec.Bignum.Base.carry t) aLen (i - 1) -> FStar.Pervasives.Lemma (requires (let _ = c1_res1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in Hacl.Spec.Bignum.Definitions.bn_v res1 - Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) == Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) - Lib.IntTypes.v c_in) <: Type0)) (ensures (let _ = Hacl.Spec.Lib.generate_elem_f aLen (Hacl.Spec.Bignum.Addition.bn_sub_carry_f a) (i - 1) c1_res1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c_out * Prims.pow2 (Lib.IntTypes.bits t * i) == Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Lib.IntTypes.v c_in) <: Type0))

FStar.Pervasives.Lemma

val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))

let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)

val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) =

let c_out, res = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[ i - 1 ] + v c1); let pbits = bits t in calc ( == ) { v c * pow2 (pbits * i) + bn_v #t #i res; ( == ) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); ( == ) { () } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[ i - 1 ]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[ i - 1 ]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[ i - 1 ]) * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) - (v c * pow2 pbits) * pow2 (pbits * (i - 1)); ( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) } eval_ aLen a (i - 1) + v c_in + v a.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))

Hacl.Spec.Bignum.Addition.fst

val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in))

Hacl.Spec.Bignum.Addition.bn_add_carry_lemma_loop_step

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> c_in: Hacl.Spec.Bignum.Base.carry t -> i: Prims.pos{i <= aLen} -> c1_res1: Hacl.Spec.Lib.generate_elem_a (Hacl.Spec.Bignum.Definitions.limb t) (Hacl.Spec.Bignum.Base.carry 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 c_in) <: Type0)) (ensures (let _ = Hacl.Spec.Lib.generate_elem_f aLen (Hacl.Spec.Bignum.Addition.bn_add_carry_f a) (i - 1) c1_res1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c_out res = _ in Lib.IntTypes.v c_out * 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 c_in) <: Type0))

FStar.Pervasives.Lemma

val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))

let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v b.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1] - v b.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)

val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i)) let bn_sub_lemma_loop_step #t #aLen a b i (c1, res1) =

let pbits = bits t in let c, res = generate_elem_f aLen (bn_sub_f a b) (i - 1) (c1, res1) in let c, e = bn_sub_f a b (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[ i - 1 ] - v b.[ i - 1 ] - v c1); calc ( == ) { bn_v #t #i res - v c * pow2 (pbits * i); ( == ) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { () } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[ i - 1 ] - v b.[ i - 1 ] + v c * pow2 pbits - v e) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ] - v b.[ i - 1 ] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[ i - 1 ] - v b.[ i - 1 ] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ] - v b.[ i - 1 ]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[ i - 1 ] - v b.[ i - 1 ]) * pow2 (pbits * (i - 1)) + (v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); ( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + (v a.[ i - 1 ] - v b.[ i - 1 ]) * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ]) (v b.[ i - 1 ]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - eval_ aLen b (i - 1) + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) - v b.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i a i } eval_ aLen a i - eval_ aLen b (i - 1) - v b.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i b i } eval_ aLen a i - eval_ aLen b i; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - eval_ aLen b i)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) val bn_add_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:nat{i <= aLen} -> Lemma (let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i) let rec bn_add_lemma_loop #t #aLen a b i = let pbits = bits t in let (c, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_f a b) (uint #t 0) in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_f a b) (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 b; () end else begin let (c1, res1) : generate_elem_a (limb t) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0) in generate_elems_unfold aLen i (bn_add_f a b) (uint #t 0) (i - 1); assert (generate_elems aLen i (bn_add_f a b) (uint #t 0) == generate_elem_f aLen (bn_add_f a b) (i - 1) (generate_elems aLen (i - 1) (bn_add_f a b) (uint #t 0))); assert ((c, res) == generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1)); bn_add_lemma_loop a b (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + eval_ aLen b (i - 1)); bn_add_lemma_loop_step a b i (c1, res1); assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i); () end val bn_add_concat_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen < aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> c0:carry t -> res0:lbignum t bLen -> Lemma (requires v c0 * pow2 (bits t * bLen) + bn_v #t #bLen res0 == eval_ bLen (sub a 0 bLen) bLen + eval_ bLen b bLen) (ensures (let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in let res = concat #_ #bLen res0 res1 in bn_v res == eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (bits t * aLen))) let bn_add_concat_lemma #t #aLen #bLen a b c0 res0 = let pbits = bits t in let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c1, res1 = bn_add_carry a1 c0 in bn_add_carry_lemma a1 c0; assert (v c1 * pow2 (pbits * (aLen - bLen)) + bn_v res1 == bn_v a1 + v c0); let res = concat #_ #bLen res0 res1 in bn_concat_lemma res0 res1; assert (bn_v res == bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1); calc (==) { bn_v #t #bLen res0 + pow2 (pbits * bLen) * bn_v res1; (==) { } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0 - v c1 * pow2 (pbits * (aLen - bLen))); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1 + v c0) (v c1 * pow2 (pbits * (aLen - bLen))) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - pow2 (pbits * bLen) * v c1 * pow2 (pbits * (aLen - bLen)); (==) { Math.Lemmas.paren_mul_right (pow2 (pbits * bLen)) (v c1) (pow2 (pbits * (aLen - bLen))); Math.Lemmas.pow2_plus (pbits * bLen) (pbits * (aLen - bLen)) } eval_ bLen a0 bLen + eval_ bLen b bLen - v c0 * pow2 (pbits * bLen) + pow2 (pbits * bLen) * (bn_v a1 + v c0) - v c1 * pow2 (pbits * aLen); (==) { Math.Lemmas.distributivity_sub_right (pow2 (pbits * bLen)) (bn_v a1) (v c0) } eval_ bLen a0 bLen + eval_ bLen b bLen + pow2 (pbits * bLen) * bn_v a1 - v c1 * pow2 (pbits * aLen); (==) { bn_eval_split_i a bLen; bn_eval_extensionality_j a (sub a 0 bLen) bLen } eval_ aLen a aLen + eval_ bLen b bLen - v c1 * pow2 (pbits * aLen); } val bn_add_lemma: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> Lemma (let (c, res) = bn_add a b in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + bn_v b) let bn_add_lemma #t #aLen #bLen a b = let pbits = bits t in let (c, res) = bn_add a b in if bLen = aLen then bn_add_lemma_loop a b aLen else begin let a0 = sub a 0 bLen in let a1 = sub a bLen (aLen - bLen) in let c0, res0 = generate_elems bLen bLen (bn_add_f a0 b) (uint #t 0) in bn_add_lemma_loop a0 b bLen; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #bLen res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma #t #aLen #bLen a b c0 res0 end val bn_add1_lemma: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> Lemma (let (c, res) = bn_add1 a b1 in v c * pow2 (bits t * aLen) + bn_v res == bn_v a + v b1) let bn_add1_lemma #t #aLen a b1 = let pbits = bits t in let c0, r0 = addcarry (uint #t 0) a.[0] b1 in assert (v c0 * pow2 pbits + v r0 = v a.[0] + v b1); let res0 = create 1 r0 in let b = create 1 b1 in bn_eval1 res0; bn_eval1 b; if aLen = 1 then bn_eval1 a else begin let bLen = 1 in let a0 = sub a 0 bLen in bn_eval1 a0; assert (v c0 * pow2 (pbits * bLen) + bn_v #t #1 res0 == eval_ bLen a0 bLen + eval_ bLen b bLen); bn_add_concat_lemma a b c0 res0 end val bn_sub_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - v c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) c1_res1 in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in)) let bn_sub_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let pbits = bits t in let (c_out, res) = generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1) in let c, e = bn_sub_carry_f a (i - 1) c1 in assert (v e - v c * pow2 pbits == v a.[i - 1] - v c1); calc (==) { bn_v #t #i res - v c * pow2 (pbits * i); (==) { bn_eval_snoc #t #(i - 1) res1 e } bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] - v e + v c * pow2 pbits) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v c * pow2 pbits) (v e) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + (v a.[i - 1] + v c * pow2 pbits) * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) + v c * pow2 pbits * pow2 (pbits * (i - 1)) - v c * pow2 (pbits * i); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) - v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i a i } eval_ aLen a i - v c_in; }; assert (bn_v #t #i res - v c * pow2 (pbits * i) == eval_ aLen a i - v c_in) val bn_sub_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in bn_v #t #i res - v c_out * pow2 (bits t * i) == eval_ aLen a i - v c_in) let rec bn_sub_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_sub_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_sub_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in in generate_elems_unfold aLen i (bn_sub_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_sub_carry_f a) c_in == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_sub_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_sub_carry_f a) (i - 1) (c1, res1)); bn_sub_carry_lemma_loop a c_in (i - 1); assert (bn_v #t #(i - 1) res1 - v c1 * pow2 (pbits * (i - 1)) == eval_ aLen a (i - 1) - v c_in); bn_sub_carry_lemma_loop_step a c_in i (c1, res1); assert (bn_v #t #i res - v c_out * pow2 (pbits * i) == eval_ aLen a i - v c_in); () end val bn_sub_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_sub_carry a c_in in bn_v res - v c_out * pow2 (bits t * aLen) == bn_v a - v c_in) let bn_sub_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_sub_carry a c_in in bn_sub_carry_lemma_loop a c_in aLen val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))

Hacl.Spec.Bignum.Addition.fst

val bn_sub_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry t) aLen (i - 1) -> Lemma (requires (let (c1, res1) = c1_res1 in bn_v #t #(i - 1) res1 - v c1 * pow2 (bits t * (i - 1)) == eval_ aLen a (i - 1) - eval_ aLen b (i - 1))) (ensures (let (c, res) = generate_elem_f aLen (bn_sub_f a b) (i - 1) c1_res1 in bn_v #t #i res - v c * pow2 (bits t * i) == eval_ aLen a i - eval_ aLen b i))

Hacl.Spec.Bignum.Addition.bn_sub_lemma_loop_step

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: 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.Base.carry t) aLen (i - 1) -> FStar.Pervasives.Lemma (requires (let _ = c1_res1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c1 res1 = _ in Hacl.Spec.Bignum.Definitions.bn_v res1 - Lib.IntTypes.v c1 * Prims.pow2 (Lib.IntTypes.bits t * (i - 1)) == Hacl.Spec.Bignum.Definitions.eval_ aLen a (i - 1) - Hacl.Spec.Bignum.Definitions.eval_ aLen b (i - 1)) <: Type0)) (ensures (let _ = Hacl.Spec.Lib.generate_elem_f aLen (Hacl.Spec.Bignum.Addition.bn_sub_f a b) (i - 1) c1_res1 in (let FStar.Pervasives.Native.Mktuple2 #_ #_ c res = _ in Hacl.Spec.Bignum.Definitions.bn_v res - Lib.IntTypes.v c * Prims.pow2 (Lib.IntTypes.bits t * i) == Hacl.Spec.Bignum.Definitions.eval_ aLen a i - Hacl.Spec.Bignum.Definitions.eval_ aLen b i) <: Type0))

FStar.Pervasives.Lemma

val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))

let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) = let pbits = bits t in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[i - 1] + v b.[i - 1] + v c1); calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1] - v b.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1] + v b.[i - 1]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[i - 1] + v b.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_add_left (v a.[i - 1]) (v b.[i - 1]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[i - 1] * pow2 (pbits * (i - 1)) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)

val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)) let bn_add_lemma_loop_step #t #aLen a b i (c1, res1) =

let pbits = bits t in let c, res = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in let c, e = bn_add_f a b (i - 1) c1 in assert (v e + v c * pow2 pbits == v a.[ i - 1 ] + v b.[ i - 1 ] + v c1); calc ( == ) { v c * pow2 (pbits * i) + bn_v #t #i res; ( == ) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); ( == ) { () } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) - (v e + v c * pow2 pbits - v a.[ i - 1 ] - v b.[ i - 1 ]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[ i - 1 ] - v b.[ i - 1 ]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v e - v e - v c * pow2 pbits + v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_sub_left (v a.[ i - 1 ] + v b.[ i - 1 ]) (v c1 * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1)) - (v c * pow2 pbits) * pow2 (pbits * (i - 1)); ( == ) { (Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + (v a.[ i - 1 ] + v b.[ i - 1 ]) * pow2 (pbits * (i - 1)); ( == ) { Math.Lemmas.distributivity_add_left (v a.[ i - 1 ]) (v b.[ i - 1 ]) (pow2 (pbits * (i - 1))) } eval_ aLen a (i - 1) + eval_ aLen b (i - 1) + v a.[ i - 1 ] * pow2 (pbits * (i - 1)) + v b.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + eval_ aLen b (i - 1) + v b.[ i - 1 ] * pow2 (pbits * (i - 1)); ( == ) { bn_eval_unfold_i #t #aLen b i } eval_ aLen a i + eval_ aLen b i; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i)

module Hacl.Spec.Bignum.Addition open FStar.Mul open Lib.IntTypes open Lib.Sequence open Hacl.Spec.Bignum.Definitions open Hacl.Spec.Bignum.Base open Hacl.Spec.Lib #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" val bn_sub_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_sub_carry_f #t #aLen a i c_in = subborrow c_in a.[i] (uint #t 0) val bn_sub_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_sub_carry #t #aLen a c_in = generate_elems aLen aLen (bn_sub_carry_f a) c_in val bn_sub_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_sub_f #t #aLen a b i c = subborrow c a.[i] b.[i] val bn_sub: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> tuple2 (carry t) (lbignum t aLen) let bn_sub #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_sub_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_sub_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_sub1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_sub1 #t #aLen a b1 = let c0, r0 = subborrow (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_sub_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> i:size_nat{i < aLen} -> c_in:carry t -> carry t & limb t let bn_add_carry_f #t #aLen a i c_in = addcarry c_in a.[i] (uint #t 0) val bn_add_carry: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> tuple2 (carry t) (lbignum t aLen) let bn_add_carry #t #aLen a c_in = generate_elems aLen aLen (bn_add_carry_f a) c_in val bn_add_f: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:size_nat{i < aLen} -> c:carry t -> carry t & limb t let bn_add_f #t #aLen a b i c = addcarry c a.[i] b.[i] val bn_add: #t:limb_t -> #aLen:size_nat -> #bLen:size_nat{bLen <= aLen} -> a:lbignum t aLen -> b:lbignum t bLen -> carry t & lbignum t aLen let bn_add #t #aLen #bLen a b = let c0, res0 = generate_elems bLen bLen (bn_add_f (sub a 0 bLen) b) (uint #t 0) in if bLen < aLen then let c1, res1 = bn_add_carry (sub a bLen (aLen - bLen)) c0 in c1, concat #_ #bLen res0 res1 else c0, res0 val bn_add1: #t:limb_t -> #aLen:size_pos -> a:lbignum t aLen -> b1:limb t -> tuple2 (carry t) (lbignum t aLen) let bn_add1 #t #aLen a b1 = let c0, r0 = addcarry (uint #t 0) a.[0] b1 in let res0 = create 1 r0 in if 1 < aLen then let c1, res1 = bn_add_carry (sub a 1 (aLen - 1)) c0 in c1, concat res0 res1 else c0, res0 val bn_add_carry_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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 c_in)) (ensures (let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) c1_res1 in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in)) let bn_add_carry_lemma_loop_step #t #aLen a c_in i (c1, res1) = let (c_out, res) = generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1) in let c, e = bn_add_carry_f a (i - 1) c1 in assert (v e + v c * pow2 (bits t) == v a.[i - 1] + v c1); let pbits = bits t in calc (==) { v c * pow2 (pbits * i) + bn_v #t #i res; (==) { bn_eval_snoc #t #(i - 1) res1 e } v c * pow2 (pbits * i) + bn_v #t #(i - 1) res1 + v e * pow2 (pbits * (i - 1)); (==) { } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in - (v e + v c * pow2 pbits - v a.[i - 1]) * pow2 (pbits * (i - 1)) + v e * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v e) (v e + v c * pow2 pbits - v a.[i - 1]) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + (v e - v e - v c * pow2 pbits + v a.[i - 1]) * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.distributivity_sub_left (v a.[i - 1]) (v c * pow2 pbits) (pow2 (pbits * (i - 1))) } v c * pow2 (pbits * i) + eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)) - v c * pow2 pbits * pow2 (pbits * (i - 1)); (==) { Math.Lemmas.paren_mul_right (v c) (pow2 pbits) (pow2 (pbits * (i - 1))); Math.Lemmas.pow2_plus pbits (pbits * (i - 1)) } eval_ aLen a (i - 1) + v c_in + v a.[i - 1] * pow2 (pbits * (i - 1)); (==) { bn_eval_unfold_i #t #aLen a i } eval_ aLen a i + v c_in; }; assert (v c * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in) val bn_add_carry_lemma_loop: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> i:nat{i <= aLen} -> Lemma (let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in v c_out * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + v c_in) let rec bn_add_carry_lemma_loop #t #aLen a c_in i = let pbits = bits t in let (c_out, res) : generate_elem_a (limb t) (carry t) aLen i = generate_elems aLen i (bn_add_carry_f a) c_in in if i = 0 then begin eq_generate_elems0 aLen i (bn_add_carry_f a) c_in; assert (c_out == c_in /\ 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) (carry t) aLen (i - 1) = generate_elems aLen (i - 1) (bn_add_carry_f a) c_in in generate_elems_unfold aLen i (bn_add_carry_f a) c_in (i - 1); assert (generate_elems aLen i (bn_add_carry_f a) c_in == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (generate_elems aLen (i - 1) (bn_add_carry_f a) c_in)); assert ((c_out, res) == generate_elem_f aLen (bn_add_carry_f a) (i - 1) (c1, res1)); bn_add_carry_lemma_loop a c_in (i - 1); assert (v c1 * pow2 (pbits * (i - 1)) + bn_v #t #(i - 1) res1 == eval_ aLen a (i - 1) + v c_in); bn_add_carry_lemma_loop_step a c_in i (c1, res1); assert (v c_out * pow2 (pbits * i) + bn_v #t #i res == eval_ aLen a i + v c_in); () end val bn_add_carry_lemma: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> c_in:carry t -> Lemma (let (c_out, res) = bn_add_carry a c_in in v c_out * pow2 (bits t * aLen) + bn_v res == bn_v a + v c_in) let bn_add_carry_lemma #t #aLen a c_in = let (c_out, res) = bn_add_carry a c_in in bn_add_carry_lemma_loop a c_in aLen val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))

Hacl.Spec.Bignum.Addition.fst

val bn_add_lemma_loop_step: #t:limb_t -> #aLen:size_nat -> a:lbignum t aLen -> b:lbignum t aLen -> i:pos{i <= aLen} -> c1_res1:generate_elem_a (limb t) (carry 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) + eval_ aLen b (i - 1))) (ensures (let (c1, res1) = c1_res1 in let (c, res) = generate_elem_f aLen (bn_add_f a b) (i - 1) (c1, res1) in v c * pow2 (bits t * i) + bn_v #t #i res == eval_ aLen a i + eval_ aLen b i))

Hacl.Spec.Bignum.Addition.bn_add_lemma_loop_step

a: Hacl.Spec.Bignum.Definitions.lbignum t aLen -> b: 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.Base.carry 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) + Hacl.Spec.Bignum.Definitions.eval_ aLen b (i - 1)) <: 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.Addition.bn_add_f a b) (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 + Hacl.Spec.Bignum.Definitions.eval_ aLen b i) <: Type0) <: Type0))

FStar.Tactics.Effect.Tac

val get_max_ifuel: Prims.unit -> Tac int

let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel

val get_max_ifuel: Prims.unit -> Tac int let get_max_ifuel () : Tac int =

(get_vconfig ()).max_ifuel

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel

FStar.Tactics.SMT.fst

val get_max_ifuel: Prims.unit -> Tac int

FStar.Tactics.SMT.get_max_ifuel

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int

FStar.Tactics.Effect.Tac

val get_initial_ifuel: Prims.unit -> Tac int

let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel

val get_initial_ifuel: Prims.unit -> Tac int let get_initial_ifuel () : Tac int =

(get_vconfig ()).initial_ifuel

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }

FStar.Tactics.SMT.fst

val get_initial_ifuel: Prims.unit -> Tac int

FStar.Tactics.SMT.get_initial_ifuel

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int

FStar.Tactics.Effect.Tac

val set_fuel (v: int) : Tac unit

let set_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v; max_fuel = v }

val set_fuel (v: int) : Tac unit let set_fuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with initial_fuel = v; max_fuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v } let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v } let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v } let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v }

FStar.Tactics.SMT.fst

val set_fuel (v: int) : Tac unit

FStar.Tactics.SMT.set_fuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val set_initial_fuel (v: int) : Tac unit

let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v }

val set_initial_fuel (v: int) : Tac unit let set_initial_fuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with initial_fuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel

FStar.Tactics.SMT.fst

val set_initial_fuel (v: int) : Tac unit

FStar.Tactics.SMT.set_initial_fuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val get_max_fuel: Prims.unit -> Tac int

let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel

val get_max_fuel: Prims.unit -> Tac int let get_max_fuel () : Tac int =

(get_vconfig ()).max_fuel

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel

FStar.Tactics.SMT.fst

val get_max_fuel: Prims.unit -> Tac int

FStar.Tactics.SMT.get_max_fuel

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int

FStar.Tactics.Effect.Tac

val smt_sync: Prims.unit -> Tac unit

let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())

val smt_sync: Prims.unit -> Tac unit let smt_sync () : Tac unit =

t_smt_sync (get_vconfig ())

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig

FStar.Tactics.SMT.fst

val smt_sync: Prims.unit -> Tac unit

FStar.Tactics.SMT.smt_sync

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val get_rlimit: Prims.unit -> Tac int

let get_rlimit () : Tac int = (get_vconfig()).z3rlimit

val get_rlimit: Prims.unit -> Tac int let get_rlimit () : Tac int =

(get_vconfig ()).z3rlimit

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *)

FStar.Tactics.SMT.fst

val get_rlimit: Prims.unit -> Tac int

FStar.Tactics.SMT.get_rlimit

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int

FStar.Tactics.Effect.Tac

val set_initial_ifuel (v: int) : Tac unit

let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v }

val set_initial_ifuel (v: int) : Tac unit let set_initial_ifuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with initial_ifuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel

FStar.Tactics.SMT.fst

val set_initial_ifuel (v: int) : Tac unit

FStar.Tactics.SMT.set_initial_ifuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val get_initial_fuel: Prims.unit -> Tac int

let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel

val get_initial_fuel: Prims.unit -> Tac int let get_initial_fuel () : Tac int =

(get_vconfig ()).initial_fuel

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }

FStar.Tactics.SMT.fst

val get_initial_fuel: Prims.unit -> Tac int

FStar.Tactics.SMT.get_initial_fuel

_: Prims.unit -> FStar.Tactics.Effect.Tac Prims.int

FStar.Tactics.Effect.Tac

val smt_sync' (fuel ifuel: nat) : Tac unit

let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg'

val smt_sync' (fuel ifuel: nat) : Tac unit let smt_sync' (fuel ifuel: nat) : Tac unit =

let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg'

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ())

FStar.Tactics.SMT.fst

val smt_sync' (fuel ifuel: nat) : Tac unit

FStar.Tactics.SMT.smt_sync'

fuel: Prims.nat -> ifuel: Prims.nat -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val set_rlimit (v: int) : Tac unit

let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v }

val set_rlimit (v: int) : Tac unit let set_rlimit (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with z3rlimit = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *)

FStar.Tactics.SMT.fst

val set_rlimit (v: int) : Tac unit

FStar.Tactics.SMT.set_rlimit

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val set_max_ifuel (v: int) : Tac unit

let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v }

val set_max_ifuel (v: int) : Tac unit let set_max_ifuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with max_ifuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v } let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v }

FStar.Tactics.SMT.fst

val set_max_ifuel (v: int) : Tac unit

FStar.Tactics.SMT.set_max_ifuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val set_max_fuel (v: int) : Tac unit

let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v }

val set_max_fuel (v: int) : Tac unit let set_max_fuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with max_fuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v }

FStar.Tactics.SMT.fst

val set_max_fuel (v: int) : Tac unit

FStar.Tactics.SMT.set_max_fuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val set_ifuel (v: int) : Tac unit

let set_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v; max_ifuel = v }

val set_ifuel (v: int) : Tac unit let set_ifuel (v: int) : Tac unit =

set_vconfig ({ get_vconfig () with initial_ifuel = v; max_ifuel = v })

module FStar.Tactics.SMT open FStar.Tactics.Effect open FStar.Tactics.V2.Builtins open FStar.VConfig (* Alias to just use the current vconfig *) let smt_sync () : Tac unit = t_smt_sync (get_vconfig ()) (* smt_sync': as smt_sync, but using a particular fuel/ifuel *) let smt_sync' (fuel ifuel : nat) : Tac unit = let vcfg = get_vconfig () in let vcfg' = { vcfg with initial_fuel = fuel; max_fuel = fuel ; initial_ifuel = ifuel; max_ifuel = ifuel } in t_smt_sync vcfg' (* Getting/setting solver configuration *) let get_rlimit () : Tac int = (get_vconfig()).z3rlimit let set_rlimit (v : int) : Tac unit = set_vconfig { get_vconfig () with z3rlimit = v } let get_initial_fuel () : Tac int = (get_vconfig ()).initial_fuel let get_initial_ifuel () : Tac int = (get_vconfig ()).initial_ifuel let get_max_fuel () : Tac int = (get_vconfig ()).max_fuel let get_max_ifuel () : Tac int = (get_vconfig ()).max_ifuel let set_initial_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_fuel = v } let set_initial_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with initial_ifuel = v } let set_max_fuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_fuel = v } let set_max_ifuel (v : int) : Tac unit = set_vconfig { get_vconfig () with max_ifuel = v } (* Set both min and max *)

FStar.Tactics.SMT.fst

val set_ifuel (v: int) : Tac unit

FStar.Tactics.SMT.set_ifuel

v: Prims.int -> FStar.Tactics.Effect.Tac Prims.unit

Prims.Tot

let point_inv_full_t (h:mem) (p:point) = F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)

let point_inv_full_t (h: mem) (p: point) =

F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p)

module Hacl.Impl.Ed25519.Verify open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module BSeq = Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module PM = Hacl.Impl.Ed25519.Ladder #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract

Hacl.Impl.Ed25519.Verify.fst

val point_inv_full_t : h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Bignum25519.point -> Prims.logical

Hacl.Impl.Ed25519.Verify.point_inv_full_t

h: FStar.Monotonic.HyperStack.mem -> p: Hacl.Bignum25519.point -> Prims.logical

FStar.HyperStack.ST.Stack

val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q)))

let verify_sb sb = push_frame (); let tmp = create 5ul (u64 0) in Hacl.Impl.Load56.load_32_bytes tmp sb; let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in pop_frame (); b

val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) let verify_sb sb =

push_frame (); let tmp = create 5ul (u64 0) in Hacl.Impl.Load56.load_32_bytes tmp sb; let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in pop_frame (); b

module Hacl.Impl.Ed25519.Verify open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module BSeq = Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module PM = Hacl.Impl.Ed25519.Ladder #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let point_inv_full_t (h:mem) (p:point) = F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) inline_for_extraction noextract val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r')))) let verify_all_valid_hb sb hb a' r' = push_frame (); let exp_d = create 20ul (u64 0) in PM.point_negate_mul_double_g_vartime exp_d sb hb a'; let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d) (Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a')) (F51.point_eval h0 r'); pop_frame (); b inline_for_extraction noextract val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q)))

Hacl.Impl.Ed25519.Verify.fst

val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q)))

Hacl.Impl.Ed25519.Verify.verify_sb

sb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

val verify: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

let verify public_key msg_len msg signature = push_frame (); let a' = create 20ul (u64 0) in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 public_key); let b = Hacl.Impl.Ed25519.PointDecompress.point_decompress a' public_key in let res = if b then verify_valid_pk public_key msg_len msg signature a' else false in pop_frame (); res

val verify: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) let verify public_key msg_len msg signature =

push_frame (); let a' = create 20ul (u64 0) in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 public_key); let b = Hacl.Impl.Ed25519.PointDecompress.point_decompress a' public_key in let res = if b then verify_valid_pk public_key msg_len msg signature a' else false in pop_frame (); res

module Hacl.Impl.Ed25519.Verify open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module BSeq = Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module PM = Hacl.Impl.Ed25519.Ladder #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let point_inv_full_t (h:mem) (p:point) = F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) inline_for_extraction noextract val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r')))) let verify_all_valid_hb sb hb a' r' = push_frame (); let exp_d = create 20ul (u64 0) in PM.point_negate_mul_double_g_vartime exp_d sb hb a'; let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d) (Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a')) (F51.point_eval h0 r'); pop_frame (); b inline_for_extraction noextract val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) let verify_sb sb = push_frame (); let tmp = create 5ul (u64 0) in Hacl.Impl.Load56.load_32_bytes tmp sb; let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in pop_frame (); b inline_for_extraction noextract val verify_valid_pk_rs: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> r':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ (Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\ (F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul))))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) let verify_valid_pk_rs public_key msg_len msg signature a' r' = push_frame (); let hb = create 32ul (u8 0) in let rs = sub signature 0ul 32ul in let sb = sub signature 32ul 32ul in let b = verify_sb sb in let res = if b then false else begin Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2 hb rs public_key msg_len msg; verify_all_valid_hb sb hb a' r' end in pop_frame (); res inline_for_extraction noextract val verify_valid_pk: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key)))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) let verify_valid_pk public_key msg_len msg signature a' = push_frame (); let r' = create 20ul (u64 0) in let rs = sub signature 0ul 32ul in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 rs); let b' = Hacl.Impl.Ed25519.PointDecompress.point_decompress r' rs in let res = if b' then verify_valid_pk_rs public_key msg_len msg signature a' r' else false in pop_frame (); res inline_for_extraction noextract val verify: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

Hacl.Impl.Ed25519.Verify.fst

val verify: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

Hacl.Impl.Ed25519.Verify.verify

public_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> msg_len: Lib.IntTypes.size_t -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len -> signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r'))))

let verify_all_valid_hb sb hb a' r' = push_frame (); let exp_d = create 20ul (u64 0) in PM.point_negate_mul_double_g_vartime exp_d sb hb a'; let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d) (Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a')) (F51.point_eval h0 r'); pop_frame (); b

val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r')))) let verify_all_valid_hb sb hb a' r' =

push_frame (); let exp_d = create 20ul (u64 0) in PM.point_negate_mul_double_g_vartime exp_d sb hb a'; let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d) (Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a')) (F51.point_eval h0 r'); pop_frame (); b

module Hacl.Impl.Ed25519.Verify open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module BSeq = Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module PM = Hacl.Impl.Ed25519.Ladder #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let point_inv_full_t (h:mem) (p:point) = F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) inline_for_extraction noextract val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r'))))

Hacl.Impl.Ed25519.Verify.fst

val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r'))))

Hacl.Impl.Ed25519.Verify.verify_all_valid_hb

sb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> hb: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> a': Hacl.Bignum25519.point -> r': Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

val verify_valid_pk: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key)))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

let verify_valid_pk public_key msg_len msg signature a' = push_frame (); let r' = create 20ul (u64 0) in let rs = sub signature 0ul 32ul in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 rs); let b' = Hacl.Impl.Ed25519.PointDecompress.point_decompress r' rs in let res = if b' then verify_valid_pk_rs public_key msg_len msg signature a' r' else false in pop_frame (); res

val verify_valid_pk: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key)))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) let verify_valid_pk public_key msg_len msg signature a' =

push_frame (); let r' = create 20ul (u64 0) in let rs = sub signature 0ul 32ul in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_decompress_lemma (as_seq h0 rs); let b' = Hacl.Impl.Ed25519.PointDecompress.point_decompress r' rs in let res = if b' then verify_valid_pk_rs public_key msg_len msg signature a' r' else false in pop_frame (); res

module Hacl.Impl.Ed25519.Verify open FStar.HyperStack open FStar.HyperStack.All open FStar.Mul open Lib.IntTypes open Lib.Buffer module ST = FStar.HyperStack.ST module BSeq = Lib.ByteSequence open Hacl.Bignum25519 module F51 = Hacl.Impl.Ed25519.Field51 module PM = Hacl.Impl.Ed25519.Ladder #reset-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction noextract let point_inv_full_t (h:mem) (p:point) = F51.point_inv_t h p /\ F51.inv_ext_point (as_seq h p) inline_for_extraction noextract val verify_all_valid_hb (sb hb:lbuffer uint8 32ul) (a' r':point) : Stack bool (requires fun h -> live h sb /\ live h hb /\ live h a' /\ live h r' /\ point_inv_full_t h a' /\ point_inv_full_t h r') (ensures fun h0 z h1 -> modifies0 h0 h1 /\ (z == Spec.Ed25519.( let exp_d = point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a') in point_equal exp_d (F51.point_eval h0 r')))) let verify_all_valid_hb sb hb a' r' = push_frame (); let exp_d = create 20ul (u64 0) in PM.point_negate_mul_double_g_vartime exp_d sb hb a'; let b = Hacl.Impl.Ed25519.PointEqual.point_equal exp_d r' in let h0 = ST.get () in Spec.Ed25519.Lemmas.point_equal_lemma (F51.point_eval h0 exp_d) (Spec.Ed25519.point_negate_mul_double_g (as_seq h0 sb) (as_seq h0 hb) (F51.point_eval h0 a')) (F51.point_eval h0 r'); pop_frame (); b inline_for_extraction noextract val verify_sb: sb:lbuffer uint8 32ul -> Stack bool (requires fun h -> live h sb) (ensures fun h0 b h1 -> modifies0 h0 h1 /\ (b <==> (BSeq.nat_from_bytes_le (as_seq h0 sb) >= Spec.Ed25519.q))) let verify_sb sb = push_frame (); let tmp = create 5ul (u64 0) in Hacl.Impl.Load56.load_32_bytes tmp sb; let b = Hacl.Impl.Ed25519.PointEqual.gte_q tmp in pop_frame (); b inline_for_extraction noextract val verify_valid_pk_rs: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> r':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ (Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\ (F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul))))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature)) let verify_valid_pk_rs public_key msg_len msg signature a' r' = push_frame (); let hb = create 32ul (u8 0) in let rs = sub signature 0ul 32ul in let sb = sub signature 32ul 32ul in let b = verify_sb sb in let res = if b then false else begin Hacl.Impl.SHA512.ModQ.store_sha512_modq_pre_pre2 hb rs public_key msg_len msg; verify_all_valid_hb sb hb a' r' end in pop_frame (); res inline_for_extraction noextract val verify_valid_pk: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key)))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

Hacl.Impl.Ed25519.Verify.fst

val verify_valid_pk: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key)))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))

Hacl.Impl.Ed25519.Verify.verify_valid_pk

public_key: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul -> msg_len: Lib.IntTypes.size_t -> msg: Lib.Buffer.lbuffer Lib.IntTypes.uint8 msg_len -> signature: Lib.Buffer.lbuffer Lib.IntTypes.uint8 64ul -> a': Hacl.Bignum25519.point -> FStar.HyperStack.ST.Stack Prims.bool

FStar.HyperStack.ST.Stack

val verify_valid_pk_rs: public_key:lbuffer uint8 32ul -> msg_len:size_t -> msg:lbuffer uint8 msg_len -> signature:lbuffer uint8 64ul -> a':point -> r':point -> Stack bool (requires fun h -> live h public_key /\ live h msg /\ live h signature /\ live h a' /\ live h r' /\ (Some? (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ point_inv_full_t h a' /\ (F51.point_eval h a' == Some?.v (Spec.Ed25519.point_decompress (as_seq h public_key))) /\ (Some? (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul)))) /\ point_inv_full_t h r' /\ (F51.point_eval h r' == Some?.v (Spec.Ed25519.point_decompress (as_seq h (gsub signature 0ul 32ul))))) (ensures fun h0 z h1 -> modifies0 h0 h1 /\ z == Spec.Ed25519.verify (as_seq h0 public_key) (as_seq h0 msg) (as_seq h0 signature))