Datasets:

microsoft

/

FStarDataSet

like 2

Follow

Microsoft 4,813

Prims.Tot

val elab_pats (ps: list pattern) : Tot (list R.pattern)

let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps

val elab_pats (ps: list pattern) : Tot (list R.pattern) let elab_pats (ps: list pattern) : Tot (list R.pattern) =

L.map elab_pat ps

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i

Pulse.Elaborate.Pure.fst

val elab_pats (ps: list pattern) : Tot (list R.pattern)

Pulse.Elaborate.Pure.elab_pats

ps: Prims.list Pulse.Syntax.Base.pattern -> Prims.list FStar.Reflection.V2.Data.pattern

Prims.Tot

val elab_st_comp (c: st_comp) : R.universe & R.term & R.term & R.term

let elab_st_comp (c:st_comp) : R.universe & R.term & R.term & R.term = let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post

val elab_st_comp (c: st_comp) : R.universe & R.term & R.term & R.term let elab_st_comp (c: st_comp) : R.universe & R.term & R.term & R.term =

let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps let elab_st_comp (c:st_comp)

Pulse.Elaborate.Pure.fst

val elab_st_comp (c: st_comp) : R.universe & R.term & R.term & R.term

Pulse.Elaborate.Pure.elab_st_comp

c: Pulse.Syntax.Base.st_comp -> ((FStar.Reflection.Types.universe * FStar.Reflection.Types.term) * FStar.Reflection.Types.term) * FStar.Reflection.Types.term

Prims.Tot

let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit

let elab_qual =

function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x

Pulse.Elaborate.Pure.fst

val elab_qual : _: FStar.Pervasives.Native.option Pulse.Syntax.Base.qualifier -> FStar.Reflection.V2.Data.aqualv

Pulse.Elaborate.Pure.elab_qual

_: FStar.Pervasives.Native.option Pulse.Syntax.Base.qualifier -> FStar.Reflection.V2.Data.aqualv

Prims.Tot

val op_let_Bang (f: option 'a) (g: ('a -> option 'b)) : option 'b

let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x

val op_let_Bang (f: option 'a) (g: ('a -> option 'b)) : option 'b let op_let_Bang (f: option 'a) (g: ('a -> option 'b)) : option 'b =

match f with | None -> None | Some x -> g x

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util

Pulse.Elaborate.Pure.fst

val op_let_Bang (f: option 'a) (g: ('a -> option 'b)) : option 'b

Pulse.Elaborate.Pure.op_let_Bang

f: FStar.Pervasives.Native.option 'a -> g: (_: 'a -> FStar.Pervasives.Native.option 'b) -> FStar.Pervasives.Native.option 'b

Prims.Tot

val elab_comp (c: comp) : R.term

let elab_comp (c:comp) : R.term = match c with | C_Tot t -> elab_term t | C_ST c -> let u, res, pre, post = elab_st_comp c in mk_stt_comp u res pre (mk_abs res R.Q_Explicit post) | C_STAtomic inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_atomic_comp u res inames pre (mk_abs res R.Q_Explicit post) | C_STGhost inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_ghost_comp u res inames pre (mk_abs res R.Q_Explicit post)

val elab_comp (c: comp) : R.term let elab_comp (c: comp) : R.term =

match c with | C_Tot t -> elab_term t | C_ST c -> let u, res, pre, post = elab_st_comp c in mk_stt_comp u res pre (mk_abs res R.Q_Explicit post) | C_STAtomic inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_atomic_comp u res inames pre (mk_abs res R.Q_Explicit post) | C_STGhost inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_ghost_comp u res inames pre (mk_abs res R.Q_Explicit post)

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps let elab_st_comp (c:st_comp) : R.universe & R.term & R.term & R.term = let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post let elab_comp (c:comp)

Pulse.Elaborate.Pure.fst

val elab_comp (c: comp) : R.term

Pulse.Elaborate.Pure.elab_comp

c: Pulse.Syntax.Base.comp -> FStar.Reflection.Types.term

Prims.Tot

val elab_term (top: term) : R.term

let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t

val elab_term (top: term) : R.term let rec elab_term (top: term) : R.term =

let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body )) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body )) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term)

Pulse.Elaborate.Pure.fst

val elab_term (top: term) : R.term

Pulse.Elaborate.Pure.elab_term

top: Pulse.Syntax.Base.term -> FStar.Reflection.Types.term

Prims.Tot

val elab_stt_equiv (g: R.env) (c: comp{C_ST? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST { u = u ; res = res } = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c)

let elab_stt_equiv (g:R.env) (c:comp{C_ST? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST {u;res} = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) = mk_stt_comp_equiv _ (comp_u c) (elab_term (comp_res c)) _ _ _ _ _ (RT.Rel_refl _ _ _) eq_pre eq_post

val elab_stt_equiv (g: R.env) (c: comp{C_ST? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST { u = u ; res = res } = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) let elab_stt_equiv (g: R.env) (c: comp{C_ST? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST { u = u ; res = res } = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) =

mk_stt_comp_equiv _ (comp_u c) (elab_term (comp_res c)) _ _ _ _ _ (RT.Rel_refl _ _ _) eq_pre eq_post

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps let elab_st_comp (c:st_comp) : R.universe & R.term & R.term & R.term = let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post let elab_comp (c:comp) : R.term = match c with | C_Tot t -> elab_term t | C_ST c -> let u, res, pre, post = elab_st_comp c in mk_stt_comp u res pre (mk_abs res R.Q_Explicit post) | C_STAtomic inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_atomic_comp u res inames pre (mk_abs res R.Q_Explicit post) | C_STGhost inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_ghost_comp u res inames pre (mk_abs res R.Q_Explicit post) let elab_stt_equiv (g:R.env) (c:comp{C_ST? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST {u;res} = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) =

Pulse.Elaborate.Pure.fst

val elab_stt_equiv (g: R.env) (c: comp{C_ST? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST { u = u ; res = res } = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c)

Pulse.Elaborate.Pure.elab_stt_equiv

g: FStar.Reflection.Types.env -> c: Pulse.Syntax.Base.comp{C_ST? c} -> pre: FStar.Reflection.Types.term -> post: FStar.Reflection.Types.term -> eq_pre: FStar.Reflection.Typing.equiv g pre (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_pre c)) -> eq_post: FStar.Reflection.Typing.equiv g post (Pulse.Reflection.Util.mk_abs (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_res c) ) FStar.Reflection.V2.Data.Q_Explicit (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_post c))) -> FStar.Reflection.Typing.equiv g (let _ = c in (let Pulse.Syntax.Base.C_ST { u = u25 ; res = res ; pre = _ ; post = _ } = _ in Pulse.Reflection.Util.mk_stt_comp u25 (Pulse.Elaborate.Pure.elab_term res) pre post) <: FStar.Reflection.Types.term) (Pulse.Elaborate.Pure.elab_comp c)

Prims.Tot

val elab_statomic_equiv (g: R.env) (c: comp{C_STAtomic? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames { u = u ; res = res } = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c)

let elab_statomic_equiv (g:R.env) (c:comp{C_STAtomic? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames {u;res} = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) = let C_STAtomic inames _ = c in mk_stt_atomic_comp_equiv _ (comp_u c) (elab_term (comp_res c)) (elab_term inames) _ _ _ _ eq_pre eq_post

val elab_statomic_equiv (g: R.env) (c: comp{C_STAtomic? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames { u = u ; res = res } = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) let elab_statomic_equiv (g: R.env) (c: comp{C_STAtomic? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames { u = u ; res = res } = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) =

let C_STAtomic inames _ = c in mk_stt_atomic_comp_equiv _ (comp_u c) (elab_term (comp_res c)) (elab_term inames) _ _ _ _ eq_pre eq_post

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps let elab_st_comp (c:st_comp) : R.universe & R.term & R.term & R.term = let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post let elab_comp (c:comp) : R.term = match c with | C_Tot t -> elab_term t | C_ST c -> let u, res, pre, post = elab_st_comp c in mk_stt_comp u res pre (mk_abs res R.Q_Explicit post) | C_STAtomic inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_atomic_comp u res inames pre (mk_abs res R.Q_Explicit post) | C_STGhost inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_ghost_comp u res inames pre (mk_abs res R.Q_Explicit post) let elab_stt_equiv (g:R.env) (c:comp{C_ST? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST {u;res} = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) = mk_stt_comp_equiv _ (comp_u c) (elab_term (comp_res c)) _ _ _ _ _ (RT.Rel_refl _ _ _) eq_pre eq_post let elab_statomic_equiv (g:R.env) (c:comp{C_STAtomic? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames {u;res} = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre

Pulse.Elaborate.Pure.fst

val elab_statomic_equiv (g: R.env) (c: comp{C_STAtomic? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames { u = u ; res = res } = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c)

Pulse.Elaborate.Pure.elab_statomic_equiv

g: FStar.Reflection.Types.env -> c: Pulse.Syntax.Base.comp{C_STAtomic? c} -> pre: FStar.Reflection.Types.term -> post: FStar.Reflection.Types.term -> eq_pre: FStar.Reflection.Typing.equiv g pre (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_pre c)) -> eq_post: FStar.Reflection.Typing.equiv g post (Pulse.Reflection.Util.mk_abs (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_res c) ) FStar.Reflection.V2.Data.Q_Explicit (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_post c))) -> FStar.Reflection.Typing.equiv g (let _ = c in (let Pulse.Syntax.Base.C_STAtomic inames { u = u32 ; res = res ; pre = _ ; post = _ } = _ in Pulse.Reflection.Util.mk_stt_atomic_comp u32 (Pulse.Elaborate.Pure.elab_term res) (Pulse.Elaborate.Pure.elab_term inames) pre post) <: FStar.Reflection.Types.term) (Pulse.Elaborate.Pure.elab_comp c)

Prims.Tot

val elab_stghost_equiv (g: R.env) (c: comp{C_STGhost? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames { u = u ; res = res } = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c)

let elab_stghost_equiv (g:R.env) (c:comp{C_STGhost? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames {u;res} = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) = let C_STGhost inames _ = c in mk_stt_ghost_comp_equiv _ (comp_u c) (elab_term (comp_res c)) (elab_term inames) _ _ _ _ eq_pre eq_post

val elab_stghost_equiv (g: R.env) (c: comp{C_STGhost? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames { u = u ; res = res } = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) let elab_stghost_equiv (g: R.env) (c: comp{C_STGhost? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames { u = u ; res = res } = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) =

let C_STGhost inames _ = c in mk_stt_ghost_comp_equiv _ (comp_u c) (elab_term (comp_res c)) (elab_term inames) _ _ _ _ eq_pre eq_post

module Pulse.Elaborate.Pure module RT = FStar.Reflection.Typing module R = FStar.Reflection.V2 module L = FStar.List.Tot module RU = Pulse.RuntimeUtils open FStar.List.Tot open Pulse.Syntax.Base open Pulse.Reflection.Util let (let!) (f:option 'a) (g: 'a -> option 'b) : option 'b = match f with | None -> None | Some x -> g x let elab_qual = function | None -> R.Q_Explicit | Some Implicit -> R.Q_Implicit let rec elab_term (top:term) : R.term = let open R in let w t' = RU.set_range t' top.range in match top.t with | Tm_VProp -> w (pack_ln (Tv_FVar (pack_fv vprop_lid))) | Tm_Emp -> w (pack_ln (Tv_FVar (pack_fv emp_lid))) | Tm_Pure p -> let p = elab_term p in let head = pack_ln (Tv_FVar (pack_fv pure_lid)) in w (pack_ln (Tv_App head (p, Q_Explicit))) | Tm_Star l r -> let l = elab_term l in let r = elab_term r in w (mk_star l r) | Tm_ExistsSL u b body | Tm_ForallSL u b body -> let t = elab_term b.binder_ty in let body = elab_term body in let t = set_range_of t b.binder_ppname.range in if Tm_ExistsSL? top.t then w (mk_exists u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) else w (mk_forall u t (mk_abs_with_name_and_range b.binder_ppname.name b.binder_ppname.range t R.Q_Explicit body)) | Tm_Inames -> w (pack_ln (Tv_FVar (pack_fv inames_lid))) | Tm_EmpInames -> w (emp_inames_tm) | Tm_Unknown -> w (pack_ln R.Tv_Unknown) | Tm_FStar t -> w t let rec elab_pat (p:pattern) : Tot R.pattern = let elab_fv (f:fv) : R.fv = R.pack_fv f.fv_name in match p with | Pat_Constant c -> R.Pat_Constant c | Pat_Var v ty -> R.Pat_Var RT.sort_default v | Pat_Cons fv vs -> R.Pat_Cons (elab_fv fv) None (Pulse.Common.map_dec p vs elab_sub_pat) | Pat_Dot_Term None -> R.Pat_Dot_Term None | Pat_Dot_Term (Some t) -> R.Pat_Dot_Term (Some (elab_term t)) and elab_sub_pat (pi : pattern & bool) : R.pattern & bool = let (p, i) = pi in elab_pat p, i let elab_pats (ps:list pattern) : Tot (list R.pattern) = L.map elab_pat ps let elab_st_comp (c:st_comp) : R.universe & R.term & R.term & R.term = let res = elab_term c.res in let pre = elab_term c.pre in let post = elab_term c.post in c.u, res, pre, post let elab_comp (c:comp) : R.term = match c with | C_Tot t -> elab_term t | C_ST c -> let u, res, pre, post = elab_st_comp c in mk_stt_comp u res pre (mk_abs res R.Q_Explicit post) | C_STAtomic inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_atomic_comp u res inames pre (mk_abs res R.Q_Explicit post) | C_STGhost inames c -> let inames = elab_term inames in let u, res, pre, post = elab_st_comp c in mk_stt_ghost_comp u res inames pre (mk_abs res R.Q_Explicit post) let elab_stt_equiv (g:R.env) (c:comp{C_ST? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_ST {u;res} = c in mk_stt_comp u (elab_term res) pre post) (elab_comp c) = mk_stt_comp_equiv _ (comp_u c) (elab_term (comp_res c)) _ _ _ _ _ (RT.Rel_refl _ _ _) eq_pre eq_post let elab_statomic_equiv (g:R.env) (c:comp{C_STAtomic? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STAtomic inames {u;res} = c in mk_stt_atomic_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c) = let C_STAtomic inames _ = c in mk_stt_atomic_comp_equiv _ (comp_u c) (elab_term (comp_res c)) (elab_term inames) _ _ _ _ eq_pre eq_post let elab_stghost_equiv (g:R.env) (c:comp{C_STGhost? c}) (pre:R.term) (post:R.term) (eq_pre:RT.equiv g pre (elab_term (comp_pre c))) (eq_post:RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames {u;res} = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre

Pulse.Elaborate.Pure.fst

val elab_stghost_equiv (g: R.env) (c: comp{C_STGhost? c}) (pre post: R.term) (eq_pre: RT.equiv g pre (elab_term (comp_pre c))) (eq_post: RT.equiv g post (mk_abs (elab_term (comp_res c)) R.Q_Explicit (elab_term (comp_post c)))) : RT.equiv g (let C_STGhost inames { u = u ; res = res } = c in mk_stt_ghost_comp u (elab_term res) (elab_term inames) pre post) (elab_comp c)

Pulse.Elaborate.Pure.elab_stghost_equiv

g: FStar.Reflection.Types.env -> c: Pulse.Syntax.Base.comp{C_STGhost? c} -> pre: FStar.Reflection.Types.term -> post: FStar.Reflection.Types.term -> eq_pre: FStar.Reflection.Typing.equiv g pre (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_pre c)) -> eq_post: FStar.Reflection.Typing.equiv g post (Pulse.Reflection.Util.mk_abs (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_res c) ) FStar.Reflection.V2.Data.Q_Explicit (Pulse.Elaborate.Pure.elab_term (Pulse.Syntax.Base.comp_post c))) -> FStar.Reflection.Typing.equiv g (let _ = c in (let Pulse.Syntax.Base.C_STGhost inames { u = u38 ; res = res ; pre = _ ; post = _ } = _ in Pulse.Reflection.Util.mk_stt_ghost_comp u38 (Pulse.Elaborate.Pure.elab_term res) (Pulse.Elaborate.Pure.elab_term inames) pre post) <: FStar.Reflection.Types.term) (Pulse.Elaborate.Pure.elab_comp c)

Prims.Tot

let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x)

let arrow (a: Type) (b: (a -> Type)) =

x: a -> Tot (b x)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *)

FStar.FunctionalExtensionality.fsti

val arrow : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.arrow

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b)

let op_Hat_Subtraction_Greater (a b: Type) =

restricted_t a (fun _ -> b)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *)

FStar.FunctionalExtensionality.fsti

val op_Hat_Subtraction_Greater : a: Type -> b: Type -> Type

FStar.FunctionalExtensionality.op_Hat_Subtraction_Greater

a: Type -> b: Type -> Type

Prims.Tot

let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x)

let arrow_g (a: Type) (b: (a -> Type)) =

x: a -> GTot (b x)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *)

FStar.FunctionalExtensionality.fsti

val arrow_g : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.arrow_g

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let efun (a: Type) (b: (a -> Type)) = arrow a b

let efun (a: Type) (b: (a -> Type)) =

arrow a b

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *)

FStar.FunctionalExtensionality.fsti

val efun : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.efun

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f}

let restricted_t (a: Type) (b: (a -> Type)) =

f: arrow a b {is_restricted a f}

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b].

FStar.FunctionalExtensionality.fsti

val restricted_t : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.restricted_t

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f

let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) =

on_domain a f == f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g]

FStar.FunctionalExtensionality.fsti

val is_restricted : a: Type -> f: FStar.FunctionalExtensionality.arrow a b -> Prims.logical

FStar.FunctionalExtensionality.is_restricted

a: Type -> f: FStar.FunctionalExtensionality.arrow a b -> Prims.logical

Prims.Tot

let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b

let efun_g (a: Type) (b: (a -> Type)) =

arrow_g a b

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *)

FStar.FunctionalExtensionality.fsti

val efun_g : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.efun_g

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x

let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) =

forall x. {:pattern (f x)\/(g x)} f x == g x

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b

FStar.FunctionalExtensionality.fsti

val feq : f: FStar.FunctionalExtensionality.arrow a b -> g: FStar.FunctionalExtensionality.arrow a b -> Prims.logical

FStar.FunctionalExtensionality.feq

f: FStar.FunctionalExtensionality.arrow a b -> g: FStar.FunctionalExtensionality.arrow a b -> Prims.logical

Prims.Tot

val on_g (a #b: Type) (f: (a -> GTot b)) : (a ^->> b)

let on_g (a #b: Type) (f: (a -> GTot b)) : (a ^->> b) = on_dom_g a f

val on_g (a #b: Type) (f: (a -> GTot b)) : (a ^->> b) let on_g (a #b: Type) (f: (a -> GTot b)) : (a ^->> b) =

on_dom_g a f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **) let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** The counterpart of [on_domain] for ghost functions *) val on_domain_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Tot (arrow_g a b) (** [on_domain_g a f] is pointwise equal to [f] *) val feq_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (feq_g (on_domain_g a f) f) [SMTPat (on_domain_g a f)] (** on_domain_g is idempotent *) val idempotence_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (on_domain_g a (on_domain_g a f) == on_domain_g a f) [SMTPat (on_domain_g a (on_domain_g a f))] (** Counterpart of [is_restricted] for ghost functions *) let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) = on_domain_g a f == f (** Counterpart of [restricted_t] for ghost functions *) let restricted_g_t (a: Type) (b: (a -> Type)) = f: arrow_g a b {is_restricted_g a f} (** [a ^->> b]: Notation for ghost, non-dependent restricted functions from [a] a to [b]. *) unfold let op_Hat_Subtraction_Greater_Greater (a b: Type) = restricted_g_t a (fun _ -> b) (** [on_dom_g a f]: A convenience function to introduce a restricted, ghost, dependent function *) unfold let on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b = on_domain_g a f (** [on_g a f]: A convenience function to introduce a restricted, ghost, non-dependent function *)

FStar.FunctionalExtensionality.fsti

val on_g (a #b: Type) (f: (a -> GTot b)) : (a ^->> b)

FStar.FunctionalExtensionality.on_g

a: Type -> f: (_: a -> Prims.GTot b) -> a ^->> b

Prims.Tot

let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) = on_domain_g a f == f

let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) =

on_domain_g a f == f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **) let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** The counterpart of [on_domain] for ghost functions *) val on_domain_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Tot (arrow_g a b) (** [on_domain_g a f] is pointwise equal to [f] *) val feq_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (feq_g (on_domain_g a f) f) [SMTPat (on_domain_g a f)] (** on_domain_g is idempotent *) val idempotence_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (on_domain_g a (on_domain_g a f) == on_domain_g a f) [SMTPat (on_domain_g a (on_domain_g a f))]

FStar.FunctionalExtensionality.fsti

val is_restricted_g : a: Type -> f: FStar.FunctionalExtensionality.arrow_g a b -> Prims.logical

FStar.FunctionalExtensionality.is_restricted_g

a: Type -> f: FStar.FunctionalExtensionality.arrow_g a b -> Prims.logical

Prims.Tot

val on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b)

let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f

val on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) =

on_dom a f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *)

FStar.FunctionalExtensionality.fsti

val on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b)

FStar.FunctionalExtensionality.on

a: Type -> f: (_: a -> b) -> a ^-> b

Prims.Tot

let op_Hat_Subtraction_Greater_Greater (a b: Type) = restricted_g_t a (fun _ -> b)

let op_Hat_Subtraction_Greater_Greater (a b: Type) =

restricted_g_t a (fun _ -> b)

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **) let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** The counterpart of [on_domain] for ghost functions *) val on_domain_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Tot (arrow_g a b) (** [on_domain_g a f] is pointwise equal to [f] *) val feq_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (feq_g (on_domain_g a f) f) [SMTPat (on_domain_g a f)] (** on_domain_g is idempotent *) val idempotence_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (on_domain_g a (on_domain_g a f) == on_domain_g a f) [SMTPat (on_domain_g a (on_domain_g a f))] (** Counterpart of [is_restricted] for ghost functions *) let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) = on_domain_g a f == f (** Counterpart of [restricted_t] for ghost functions *) let restricted_g_t (a: Type) (b: (a -> Type)) = f: arrow_g a b {is_restricted_g a f} (** [a ^->> b]: Notation for ghost, non-dependent restricted functions from [a] a to [b]. *)

FStar.FunctionalExtensionality.fsti

val op_Hat_Subtraction_Greater_Greater : a: Type -> b: Type -> Type

FStar.FunctionalExtensionality.op_Hat_Subtraction_Greater_Greater

a: Type -> b: Type -> Type

Prims.Tot

let restricted_g_t (a: Type) (b: (a -> Type)) = f: arrow_g a b {is_restricted_g a f}

let restricted_g_t (a: Type) (b: (a -> Type)) =

f: arrow_g a b {is_restricted_g a f}

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **) let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** The counterpart of [on_domain] for ghost functions *) val on_domain_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Tot (arrow_g a b) (** [on_domain_g a f] is pointwise equal to [f] *) val feq_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (feq_g (on_domain_g a f) f) [SMTPat (on_domain_g a f)] (** on_domain_g is idempotent *) val idempotence_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (on_domain_g a (on_domain_g a f) == on_domain_g a f) [SMTPat (on_domain_g a (on_domain_g a f))] (** Counterpart of [is_restricted] for ghost functions *) let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) = on_domain_g a f == f

FStar.FunctionalExtensionality.fsti

val restricted_g_t : a: Type -> b: (_: a -> Type) -> Type

FStar.FunctionalExtensionality.restricted_g_t

a: Type -> b: (_: a -> Type) -> Type

Prims.Tot

let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x

let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) =

forall x. {:pattern (f x)\/(g x)} f x == g x

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **)

FStar.FunctionalExtensionality.fsti

val feq_g : f: FStar.FunctionalExtensionality.arrow_g a b -> g: FStar.FunctionalExtensionality.arrow_g a b -> Prims.logical

FStar.FunctionalExtensionality.feq_g

f: FStar.FunctionalExtensionality.arrow_g a b -> g: FStar.FunctionalExtensionality.arrow_g a b -> Prims.logical

Prims.Tot

val on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b

let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f

val on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b =

on_domain a f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *)

FStar.FunctionalExtensionality.fsti

val on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b

FStar.FunctionalExtensionality.on_dom

a: Type -> f: FStar.FunctionalExtensionality.arrow a b -> FStar.FunctionalExtensionality.restricted_t a b

Prims.Tot

val on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b

let on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b = on_domain_g a f

val on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b let on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b =

on_domain_g a f

(* Copyright 2008-2018 Microsoft Research Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or 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 FStar.FunctionalExtensionality /// Functional extensionality asserts the equality of pointwise-equal /// functions. /// /// The formulation of this axiom is particularly subtle in F* because /// of its interaction with subtyping. In fact, prior formulations of /// this axiom were discovered to be unsound by Aseem Rastogi. /// /// The predicate [feq #a #b f g] asserts that [f, g: x:a -> (b x)] are /// pointwise equal on the domain [a]. /// /// However, due to subtyping [f] and [g] may also be defined on some /// domain larger than [a]. We need to be careful to ensure that merely /// proving [f] and [g] equal on their sub-domain [a] does not lead us /// to conclude that they are equal everywhere. /// /// For more context on how functional extensionality works in F*, see /// 1. tests/micro-benchmarks/Test.FunctionalExtensionality.fst /// 2. ulib/FStar.Map.fst and ulib/FStar.Map.fsti /// 3. Issue #1542 on github.com/FStarLang/FStar/issues/1542 (** The type of total, dependent functions *) unfold let arrow (a: Type) (b: (a -> Type)) = x: a -> Tot (b x) (** Using [arrow] instead *) [@@ (deprecated "Use arrow instead")] let efun (a: Type) (b: (a -> Type)) = arrow a b (** feq #a #b f g: pointwise equality of [f] and [g] on domain [a] *) let feq (#a: Type) (#b: (a -> Type)) (f g: arrow a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** [on_domain a f]: This is a key function provided by the module. It has several features. 1. Intuitively, [on_domain a f] can be seen as a function whose maximal domain is [a]. 2. While, [on_domain a f] is proven to be *pointwise* equal to [f], crucially it is not provably equal to [f], since [f] may actually have a domain larger than [a]. 3. [on_domain] is idempotent 4. [on_domain a f x] has special treatment in F*'s normalizer. It reduces to [f x], reflecting the pointwise equality of [on_domain a f] and [f]. 5. [on_domain] is marked [inline_for_extraction], to eliminate the overhead of an indirection in extracted code. (This feature will be exercised as part of cross-module inlining across interface boundaries) *) inline_for_extraction val on_domain (a: Type) (#b: (a -> Type)) ([@@@strictly_positive] f: arrow a b) : Tot (arrow a b) (** feq_on_domain: [on_domain a f] is pointwise equal to [f] *) val feq_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (feq (on_domain a f) f) [SMTPat (on_domain a f)] (** on_domain is idempotent *) val idempotence_on_domain (#a: Type) (#b: (a -> Type)) (f: arrow a b) : Lemma (on_domain a (on_domain a f) == on_domain a f) [SMTPat (on_domain a (on_domain a f))] (** [is_restricted a f]: Though stated indirectly, [is_restricted a f] is valid when [f] is a function whose maximal domain is equal to [a]. Equivalently, one may see its definition as [exists g. f == on_domain a g] *) let is_restricted (a: Type) (#b: (a -> Type)) (f: arrow a b) = on_domain a f == f (** restricted_t a b: Lifts the [is_restricted] predicate into a refinement type This is the type of functions whose maximal domain is [a] and whose (dependent) co-domain is [b]. *) let restricted_t (a: Type) (b: (a -> Type)) = f: arrow a b {is_restricted a f} (** [a ^-> b]: Notation for non-dependent restricted functions from [a] to [b]. The first symbol [^] makes it right associative, as expected for arrows. *) unfold let op_Hat_Subtraction_Greater (a b: Type) = restricted_t a (fun _ -> b) (** [on_dom a f]: A convenience function to introduce a restricted, dependent function *) unfold let on_dom (a: Type) (#b: (a -> Type)) (f: arrow a b) : restricted_t a b = on_domain a f (** [on a f]: A convenience function to introduce a restricted, non-dependent function *) unfold let on (a #b: Type) (f: (a -> Tot b)) : (a ^-> b) = on_dom a f (**** MAIN AXIOM *) (** [extensionality]: The main axiom of this module states that functions [f] and [g] that are pointwise equal on domain [a] are provably equal when restricted to [a] *) val extensionality (a: Type) (b: (a -> Type)) (f g: arrow a b) : Lemma (ensures (feq #a #b f g <==> on_domain a f == on_domain a g)) [SMTPat (feq #a #b f g)] (**** DUPLICATED FOR GHOST FUNCTIONS *) (** The type of ghost, total, dependent functions *) unfold let arrow_g (a: Type) (b: (a -> Type)) = x: a -> GTot (b x) (** Use [arrow_g] instead *) [@@ (deprecated "Use arrow_g instead")] let efun_g (a: Type) (b: (a -> Type)) = arrow_g a b (** [feq_g #a #b f g]: pointwise equality of [f] and [g] on domain [a] **) let feq_g (#a: Type) (#b: (a -> Type)) (f g: arrow_g a b) = forall x. {:pattern (f x)\/(g x)} f x == g x (** The counterpart of [on_domain] for ghost functions *) val on_domain_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Tot (arrow_g a b) (** [on_domain_g a f] is pointwise equal to [f] *) val feq_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (feq_g (on_domain_g a f) f) [SMTPat (on_domain_g a f)] (** on_domain_g is idempotent *) val idempotence_on_domain_g (#a: Type) (#b: (a -> Type)) (f: arrow_g a b) : Lemma (on_domain_g a (on_domain_g a f) == on_domain_g a f) [SMTPat (on_domain_g a (on_domain_g a f))] (** Counterpart of [is_restricted] for ghost functions *) let is_restricted_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) = on_domain_g a f == f (** Counterpart of [restricted_t] for ghost functions *) let restricted_g_t (a: Type) (b: (a -> Type)) = f: arrow_g a b {is_restricted_g a f} (** [a ^->> b]: Notation for ghost, non-dependent restricted functions from [a] a to [b]. *) unfold let op_Hat_Subtraction_Greater_Greater (a b: Type) = restricted_g_t a (fun _ -> b) (** [on_dom_g a f]: A convenience function to introduce a restricted, ghost, dependent function *)

FStar.FunctionalExtensionality.fsti

val on_dom_g (a: Type) (#b: (a -> Type)) (f: arrow_g a b) : restricted_g_t a b

FStar.FunctionalExtensionality.on_dom_g

a: Type -> f: FStar.FunctionalExtensionality.arrow_g a b -> FStar.FunctionalExtensionality.restricted_g_t a b

Prims.Tot

let u32_between (s f:US.t) = x:US.t { US.v s <= US.v x /\ US.v x < US.v f}

let u32_between (s f: US.t) =

x: US.t{US.v s <= US.v x /\ US.v x < US.v f}

(* Copyright 2021 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.ST.Loops module US = FStar.SizeT open Steel.ST.Util (* This module provides some common iterative looping combinators *) let nat_at_most (f:US.t) = x:nat{ x <= US.v f }

Steel.ST.Loops.fsti

val u32_between : s: FStar.SizeT.t -> f: FStar.SizeT.t -> Type0

Steel.ST.Loops.u32_between

s: FStar.SizeT.t -> f: FStar.SizeT.t -> Type0

Prims.Tot

let nat_at_most (f:US.t) = x:nat{ x <= US.v f }

let nat_at_most (f: US.t) =

x: nat{x <= US.v f}

(* Copyright 2021 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.ST.Loops module US = FStar.SizeT open Steel.ST.Util (* This module provides some common iterative looping combinators *)

Steel.ST.Loops.fsti

val nat_at_most : f: FStar.SizeT.t -> Type0

Steel.ST.Loops.nat_at_most

f: FStar.SizeT.t -> Type0

FStar.Tactics.Effect.Tac

val forall_maybe_enum_key_unknown_tac: Prims.unit -> T.Tac unit

let forall_maybe_enum_key_unknown_tac () : T.Tac unit = let open T in let x = intro () in norm [delta; iota; zeta; primops]; trivial (); qed ()

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

let open T in let x = intro () in norm [delta; iota; zeta; primops]; trivial (); qed ()

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed () noextract let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e noextract let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote enum_repr_of_key_cons_nil') (quote enum_repr_of_key_cons') e noextract let synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit = let open T in destruct (quote x); to_all_goals (fun () -> let breq = intros_until_squash () in rewrite breq; norm [delta; iota; zeta; primops]; trivial (); qed () ); qed () noextract let forall_maybe_enum_key_known_tac () : T.Tac unit = let open T in norm [delta; iota; zeta; primops]; trivial (); qed () noextract

LowParse.Spec.Tac.Enum.fst

val forall_maybe_enum_key_unknown_tac: Prims.unit -> T.Tac unit

LowParse.Spec.Tac.Enum.forall_maybe_enum_key_unknown_tac

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

FStar.Tactics.Effect.Tac

val forall_maybe_enum_key_known_tac: Prims.unit -> T.Tac unit

let forall_maybe_enum_key_known_tac () : T.Tac unit = let open T in norm [delta; iota; zeta; primops]; trivial (); qed ()

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

let open T in norm [delta; iota; zeta; primops]; trivial (); qed ()

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed () noextract let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e noextract let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote enum_repr_of_key_cons_nil') (quote enum_repr_of_key_cons') e noextract let synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit = let open T in destruct (quote x); to_all_goals (fun () -> let breq = intros_until_squash () in rewrite breq; norm [delta; iota; zeta; primops]; trivial (); qed () ); qed () noextract

LowParse.Spec.Tac.Enum.fst

val forall_maybe_enum_key_known_tac: Prims.unit -> T.Tac unit

LowParse.Spec.Tac.Enum.forall_maybe_enum_key_known_tac

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

FStar.Tactics.Effect.Tac

val apply (t: T.term) : T.Tac unit

let apply (t:T.term) : T.Tac unit = T.t_apply true false true t

val apply (t: T.term) : T.Tac unit let apply (t: T.term) : T.Tac unit =

T.t_apply true false true t

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate //

LowParse.Spec.Tac.Enum.fst

val apply (t: T.term) : T.Tac unit

LowParse.Spec.Tac.Enum.apply

t: FStar.Reflection.Types.term -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e

val maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit =

enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed () noextract let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr))

LowParse.Spec.Tac.Enum.fst

val maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

LowParse.Spec.Tac.Enum.maybe_enum_key_of_repr_tac

e: Prims.list (key * repr) -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote enum_repr_of_key_cons_nil') (quote enum_repr_of_key_cons') e

val enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit =

enum_tac_gen (quote enum_repr_of_key_cons_nil') (quote enum_repr_of_key_cons') e

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed () noextract let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e noextract let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr))

LowParse.Spec.Tac.Enum.fst

val enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

LowParse.Spec.Tac.Enum.enum_repr_of_key_tac

e: Prims.list (key * repr) -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit

let synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit = let open T in destruct (quote x); to_all_goals (fun () -> let breq = intros_until_squash () in rewrite breq; norm [delta; iota; zeta; primops]; trivial (); qed () ); qed ()

val synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit let synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit =

let open T in destruct (quote x); to_all_goals (fun () -> let breq = intros_until_squash () in rewrite breq; norm [delta; iota; zeta; primops]; trivial (); qed ()); qed ()

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed () noextract let maybe_enum_key_of_repr_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote maybe_enum_key_of_repr'_t_cons_nil') (quote maybe_enum_key_of_repr'_t_cons') e noextract let enum_repr_of_key_tac (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = enum_tac_gen (quote enum_repr_of_key_cons_nil') (quote enum_repr_of_key_cons') e noextract

LowParse.Spec.Tac.Enum.fst

val synth_maybe_enum_key_inv_unknown_tac (#key: Type) (x: key) : T.Tac unit

LowParse.Spec.Tac.Enum.synth_maybe_enum_key_inv_unknown_tac

x: key -> FStar.Tactics.Effect.Tac Prims.unit

FStar.Tactics.Effect.Tac

val enum_tac_gen (t_cons_nil t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit = match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [ T.solve_vc; T.solve_vc; ]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [ T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_); ]; T.qed ()

val enum_tac_gen (t_cons_nil t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit let rec enum_tac_gen (t_cons_nil t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit =

match e with | [] -> T.fail "enum_tac_gen: e must be cons" | [_] -> apply t_cons_nil; T.iseq [T.solve_vc; T.solve_vc]; T.qed () | _ :: e_ -> apply t_cons; T.iseq [T.solve_vc; (fun () -> enum_tac_gen t_cons_nil t_cons e_)]; T.qed ()

module LowParse.Spec.Tac.Enum include LowParse.Spec.Enum module T = LowParse.TacLib // // The enum tactic solves goals of type ?u:eqtype with enum types that are // in the environment at type Type0 // So typechecking such uvars fails since F* 2635 bug fix // (since uvar solutions are checked with smt off) // // To circumvent that, we use t_apply with tc_resolve_uvars flag on, // so that ?u will be typechecked as soon as it is resolved, // resulting in an smt guard that will be added to the proofstate // let apply (t:T.term) : T.Tac unit = T.t_apply true false true t noextract let rec enum_tac_gen (t_cons_nil: T.term) (t_cons: T.term) (#key #repr: Type) (e: list (key * repr))

LowParse.Spec.Tac.Enum.fst

val enum_tac_gen (t_cons_nil t_cons: T.term) (#key #repr: Type) (e: list (key * repr)) : T.Tac unit

LowParse.Spec.Tac.Enum.enum_tac_gen

t_cons_nil: FStar.Reflection.Types.term -> t_cons: FStar.Reflection.Types.term -> e: Prims.list (key * repr) -> FStar.Tactics.Effect.Tac Prims.unit

Prims.Tot

let vec_t4 (t:v_inttype) = vec_t t 4 & vec_t t 4 & vec_t t 4 & vec_t t 4

let vec_t4 (t: v_inttype) =

vec_t t 4 & vec_t t 4 & vec_t t 4 & vec_t t 4

module Lib.IntVector.Transpose open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector #set-options "--z3rlimit 50 --fuel 0 --ifuel 0"

Lib.IntVector.Transpose.fsti

val vec_t4 : t: Lib.IntVector.v_inttype -> Type0

Lib.IntVector.Transpose.vec_t4

t: Lib.IntVector.v_inttype -> Type0

Prims.Tot

let vec_t8 (t:v_inttype) = vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8

let vec_t8 (t: v_inttype) =

vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8

module Lib.IntVector.Transpose open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction let vec_t4 (t:v_inttype) = vec_t t 4 & vec_t t 4 & vec_t t 4 & vec_t t 4

Lib.IntVector.Transpose.fsti

val vec_t8 : t: Lib.IntVector.v_inttype -> Type0

Lib.IntVector.Transpose.vec_t8

t: Lib.IntVector.v_inttype -> Type0

Prims.Tot

val transpose4x4_lseq (#t: v_inttype{t = U32 \/ t = U64}) (vs: lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4

let transpose4x4_lseq (#t:v_inttype{t = U32 \/ t = U64}) (vs:lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4 = let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in let (r0,r1,r2,r3) = transpose4x4 (v0,v1,v2,v3) in create4 r0 r1 r2 r3

val transpose4x4_lseq (#t: v_inttype{t = U32 \/ t = U64}) (vs: lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4 let transpose4x4_lseq (#t: v_inttype{t = U32 \/ t = U64}) (vs: lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4 =

let v0, v1, v2, v3 = (vs.[ 0 ], vs.[ 1 ], vs.[ 2 ], vs.[ 3 ]) in let r0, r1, r2, r3 = transpose4x4 (v0, v1, v2, v3) in create4 r0 r1 r2 r3

module Lib.IntVector.Transpose open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction let vec_t4 (t:v_inttype) = vec_t t 4 & vec_t t 4 & vec_t t 4 & vec_t t 4 inline_for_extraction let vec_t8 (t:v_inttype) = vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 inline_for_extraction val transpose4x4: #t:v_inttype{t = U32 \/ t = U64} -> vec_t4 t -> vec_t4 t inline_for_extraction val transpose8x8: #t:v_inttype{t = U32} -> vec_t8 t -> vec_t8 t

Lib.IntVector.Transpose.fsti

val transpose4x4_lseq (#t: v_inttype{t = U32 \/ t = U64}) (vs: lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4

Lib.IntVector.Transpose.transpose4x4_lseq

vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4 -> Lib.Sequence.lseq (Lib.IntVector.vec_t t 4) 4

Prims.Tot

val transpose8x8_lseq (#t: v_inttype{t = U32}) (vs: lseq (vec_t t 8) 8) : lseq (vec_t t 8) 8

let transpose8x8_lseq (#t:v_inttype{t = U32}) (vs:lseq (vec_t t 8) 8) : lseq (vec_t t 8) 8 = let (v0,v1,v2,v3,v4,v5,v6,v7) = (vs.[0],vs.[1],vs.[2],vs.[3],vs.[4],vs.[5],vs.[6],vs.[7]) in let (r0,r1,r2,r3,r4,r5,r6,r7) = transpose8x8 (v0,v1,v2,v3,v4,v5,v6,v7) in create8 r0 r1 r2 r3 r4 r5 r6 r7

val transpose8x8_lseq (#t: v_inttype{t = U32}) (vs: lseq (vec_t t 8) 8) : lseq (vec_t t 8) 8 let transpose8x8_lseq (#t: v_inttype{t = U32}) (vs: lseq (vec_t t 8) 8) : lseq (vec_t t 8) 8 =

let v0, v1, v2, v3, v4, v5, v6, v7 = (vs.[ 0 ], vs.[ 1 ], vs.[ 2 ], vs.[ 3 ], vs.[ 4 ], vs.[ 5 ], vs.[ 6 ], vs.[ 7 ]) in let r0, r1, r2, r3, r4, r5, r6, r7 = transpose8x8 (v0, v1, v2, v3, v4, v5, v6, v7) in create8 r0 r1 r2 r3 r4 r5 r6 r7

module Lib.IntVector.Transpose open FStar.Mul open Lib.IntTypes open Lib.Sequence open Lib.IntVector #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" inline_for_extraction let vec_t4 (t:v_inttype) = vec_t t 4 & vec_t t 4 & vec_t t 4 & vec_t t 4 inline_for_extraction let vec_t8 (t:v_inttype) = vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 & vec_t t 8 inline_for_extraction val transpose4x4: #t:v_inttype{t = U32 \/ t = U64} -> vec_t4 t -> vec_t4 t inline_for_extraction val transpose8x8: #t:v_inttype{t = U32} -> vec_t8 t -> vec_t8 t inline_for_extraction let transpose4x4_lseq (#t:v_inttype{t = U32 \/ t = U64}) (vs:lseq (vec_t t 4) 4) : lseq (vec_t t 4) 4 = let (v0,v1,v2,v3) = (vs.[0],vs.[1],vs.[2],vs.[3]) in let (r0,r1,r2,r3) = transpose4x4 (v0,v1,v2,v3) in create4 r0 r1 r2 r3

Lib.IntVector.Transpose.fsti

val transpose8x8_lseq (#t: v_inttype{t = U32}) (vs: lseq (vec_t t 8) 8) : lseq (vec_t t 8) 8

Lib.IntVector.Transpose.transpose8x8_lseq

vs: Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8 -> Lib.Sequence.lseq (Lib.IntVector.vec_t t 8) 8

Prims.Pure

let fail_parser = tot_fail_parser

let fail_parser =

tot_fail_parser

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base

LowParse.Tot.Combinators.fst

val fail_parser : k: LowParse.Spec.Base.parser_kind -> t: Type -> Prims.Pure (LowParse.Spec.Base.tot_parser k t)

LowParse.Tot.Combinators.fail_parser

k: LowParse.Spec.Base.parser_kind -> t: Type -> Prims.Pure (LowParse.Spec.Base.tot_parser k t)

Prims.Tot

val parse_empty:parser parse_ret_kind unit

let parse_empty : parser parse_ret_kind unit = parse_ret ()

val parse_empty:parser parse_ret_kind unit let parse_empty:parser parse_ret_kind unit =

parse_ret ()

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction

LowParse.Tot.Combinators.fst

val parse_empty:parser parse_ret_kind unit

LowParse.Tot.Combinators.parse_empty

LowParse.Tot.Base.parser LowParse.Spec.Combinators.parse_ret_kind Prims.unit

Prims.Tot

let parse_ret = tot_parse_ret

let parse_ret =

tot_parse_ret

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser

LowParse.Tot.Combinators.fst

val parse_ret : v: _ -> LowParse.Spec.Base.tot_parser LowParse.Spec.Combinators.parse_ret_kind _

LowParse.Tot.Combinators.parse_ret

v: _ -> LowParse.Spec.Base.tot_parser LowParse.Spec.Combinators.parse_ret_kind _

Prims.Tot

val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t)

let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t

val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t =

tot_parse_tagged_union #kt #tag_t

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t)

LowParse.Tot.Combinators.fst

val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t)

LowParse.Tot.Combinators.parse_tagged_union

pt: LowParse.Tot.Base.parser kt tag_t -> tag_of_data: (_: data_t -> tag_t) -> p: (t: tag_t -> LowParse.Tot.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) -> LowParse.Tot.Base.parser (LowParse.Spec.Combinators.and_then_kind kt k) data_t

Prims.Tot

val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2))

let nondep_then #k1 = tot_nondep_then #k1

val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2)) let nondep_then #k1 =

tot_nondep_then #k1

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end )) let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input = parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True)) let serialize_tagged_union #kt st tag_of_data #k s = serialize_tot_tagged_union #kt st tag_of_data #k s val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2))

LowParse.Tot.Combinators.fst

val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2))

LowParse.Tot.Combinators.nondep_then

p1: LowParse.Tot.Base.parser k1 t1 -> p2: LowParse.Tot.Base.parser k2 t2 -> LowParse.Tot.Base.parser (LowParse.Spec.Combinators.and_then_kind k1 k2) (t1 * t2)

Prims.Tot

val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t)

let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t

val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t =

tot_parse_tagged_union_payload #tag_t #data_t

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t)

LowParse.Tot.Combinators.fst

val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t)

LowParse.Tot.Combinators.parse_tagged_union_payload

tag_of_data: (_: data_t -> tag_t) -> p: (t: tag_t -> LowParse.Tot.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) -> tg: tag_t -> LowParse.Tot.Base.parser k data_t

Prims.Tot

val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2))

let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2

val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 =

serialize_tot_synth #k #t1 #t2

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2))

LowParse.Tot.Combinators.fst

val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2))

LowParse.Tot.Combinators.serialize_synth

p1: LowParse.Spec.Base.tot_parser k t1 -> f2: (_: t1 -> t2) -> s1: LowParse.Tot.Base.serializer p1 -> g1: (_: t2 -> Prims.GTot t1) -> u30: u33: Prims.unit { LowParse.Spec.Combinators.synth_inverse f2 g1 /\ LowParse.Spec.Combinators.synth_injective f2 } -> LowParse.Tot.Base.serializer (LowParse.Spec.Combinators.tot_parse_synth p1 f2)

Prims.Pure

val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True))

let serialize_tagged_union #kt st tag_of_data #k s = serialize_tot_tagged_union #kt st tag_of_data #k s

val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True)) let serialize_tagged_union #kt st tag_of_data #k s =

serialize_tot_tagged_union #kt st tag_of_data #k s

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end )) let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input = parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True))

LowParse.Tot.Combinators.fst

val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True))

LowParse.Tot.Combinators.serialize_tagged_union

st: LowParse.Tot.Base.serializer pt -> tag_of_data: (_: data_t -> tag_t) -> s: (t: tag_t -> LowParse.Tot.Base.serializer (p t)) -> Prims.Pure (LowParse.Tot.Base.serializer (LowParse.Tot.Combinators.parse_tagged_union pt tag_of_data p))

FStar.Pervasives.Lemma

val parse_tagged_union_payload_and_then_cases_injective (#tag_t #data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t)))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p))

let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p

val parse_tagged_union_payload_and_then_cases_injective (#tag_t #data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t)))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) let parse_tagged_union_payload_and_then_cases_injective (#tag_t #data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t)))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) =

parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma

LowParse.Tot.Combinators.fst

val parse_tagged_union_payload_and_then_cases_injective (#tag_t #data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t)))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p))

LowParse.Tot.Combinators.parse_tagged_union_payload_and_then_cases_injective

tag_of_data: (_: data_t -> tag_t) -> p: (t: tag_t -> LowParse.Tot.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Combinators.and_then_cases_injective (LowParse.Tot.Combinators.parse_tagged_union_payload tag_of_data p))

Prims.Tot

val serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f))

let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _

val serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) =

Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool))

LowParse.Tot.Combinators.fst

val serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f))

LowParse.Tot.Combinators.serialize_filter

s: LowParse.Tot.Base.serializer p -> f: (_: t -> Prims.bool) -> LowParse.Tot.Base.serializer (LowParse.Tot.Combinators.parse_filter p f)

Prims.Pure

val make_constant_size_parser (sz: nat) (t: Type) (f: (s: bytes{Seq.length s == sz} -> Tot (option t))) : Pure (tot_parser (constant_size_parser_kind sz) t) (requires (make_constant_size_parser_precond sz t f)) (ensures (fun _ -> True))

let make_constant_size_parser (sz: nat) (t: Type) (f: ((s: bytes {Seq.length s == sz}) -> Tot (option t))) : Pure ( tot_parser (constant_size_parser_kind sz) t ) (requires ( make_constant_size_parser_precond sz t f )) (ensures (fun _ -> True)) = tot_make_constant_size_parser sz t f

val make_constant_size_parser (sz: nat) (t: Type) (f: (s: bytes{Seq.length s == sz} -> Tot (option t))) : Pure (tot_parser (constant_size_parser_kind sz) t) (requires (make_constant_size_parser_precond sz t f)) (ensures (fun _ -> True)) let make_constant_size_parser (sz: nat) (t: Type) (f: (s: bytes{Seq.length s == sz} -> Tot (option t))) : Pure (tot_parser (constant_size_parser_kind sz) t) (requires (make_constant_size_parser_precond sz t f)) (ensures (fun _ -> True)) =

tot_make_constant_size_parser sz t f

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end )) let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input = parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True)) let serialize_tagged_union #kt st tag_of_data #k s = serialize_tot_tagged_union #kt st tag_of_data #k s val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2)) let nondep_then #k1 = tot_nondep_then #k1 val nondep_then_eq (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) (b: bytes) : Lemma (parse (nondep_then p1 p2) b == (match parse p1 b with | Some (x1, consumed1) -> let b' = Seq.slice b consumed1 (Seq.length b) in begin match parse p2 b' with | Some (x2, consumed2) -> Some ((x1, x2), consumed1 + consumed2) | _ -> None end | _ -> None )) let nondep_then_eq #k1 #t1 p1 #k2 #t2 p2 b = nondep_then_eq #k1 p1 #k2 p2 b let make_constant_size_parser (sz: nat) (t: Type) (f: ((s: bytes {Seq.length s == sz}) -> Tot (option t))) : Pure ( tot_parser (constant_size_parser_kind sz) t ) (requires ( make_constant_size_parser_precond sz t f ))

LowParse.Tot.Combinators.fst

val make_constant_size_parser (sz: nat) (t: Type) (f: (s: bytes{Seq.length s == sz} -> Tot (option t))) : Pure (tot_parser (constant_size_parser_kind sz) t) (requires (make_constant_size_parser_precond sz t f)) (ensures (fun _ -> True))

LowParse.Tot.Combinators.make_constant_size_parser

sz: Prims.nat -> t: Type -> f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> FStar.Pervasives.Native.option t) -> Prims.Pure (LowParse.Spec.Base.tot_parser (LowParse.Spec.Combinators.constant_size_parser_kind sz) t)

Prims.Tot

val serialize_weaken (#k: parser_kind) (#t: Type) (k': parser_kind) (#p: parser k t) (s: serializer p {k' `is_weaker_than` k}) : Tot (serializer (weaken k' p))

let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s

val serialize_weaken (#k: parser_kind) (#t: Type) (k': parser_kind) (#p: parser k t) (s: serializer p {k' `is_weaker_than` k}) : Tot (serializer (weaken k' p)) let serialize_weaken (#k: parser_kind) (#t: Type) (k': parser_kind) (#p: parser k t) (s: serializer p {k' `is_weaker_than` k}) : Tot (serializer (weaken k' p)) =

serialize_weaken #k k' s

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k })

LowParse.Tot.Combinators.fst

val serialize_weaken (#k: parser_kind) (#t: Type) (k': parser_kind) (#p: parser k t) (s: serializer p {k' `is_weaker_than` k}) : Tot (serializer (weaken k' p))

LowParse.Tot.Combinators.serialize_weaken

k': LowParse.Spec.Base.parser_kind -> s: LowParse.Tot.Base.serializer p {LowParse.Spec.Base.is_weaker_than k' k} -> LowParse.Tot.Base.serializer (LowParse.Tot.Base.weaken k' p)

FStar.Pervasives.Lemma

val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b))

let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2

val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 =

tot_parse_synth_eq #k #t1 #t2

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b))

LowParse.Tot.Combinators.fst

val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b))

LowParse.Tot.Combinators.parse_synth_eq

p1: LowParse.Tot.Base.parser k t1 -> f2: (_: t1 -> t2) -> b: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (requires LowParse.Spec.Combinators.synth_injective f2) (ensures LowParse.Spec.Base.parse (LowParse.Tot.Combinators.parse_synth p1 f2) b == LowParse.Spec.Combinators.parse_synth' p1 f2 b)

FStar.Pervasives.Lemma

val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input))

let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input

val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input =

and_then_eq #k #t p #k' #t' p' input

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input))

LowParse.Tot.Combinators.fst

val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input))

LowParse.Tot.Combinators.and_then_eq

p: LowParse.Tot.Base.parser k t -> p': (_: t -> LowParse.Tot.Base.parser k' t') -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (requires LowParse.Spec.Combinators.and_then_cases_injective p') (ensures LowParse.Spec.Base.parse (LowParse.Tot.Combinators.and_then p p') input == LowParse.Spec.Combinators.and_then_bare p p' input)

FStar.Pervasives.Lemma

val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None ))

let parse_filter_eq #k #t = tot_parse_filter_eq #k #t

val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t =

tot_parse_filter_eq #k #t

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None ))

LowParse.Tot.Combinators.fst

val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None ))

LowParse.Tot.Combinators.parse_filter_eq

p: LowParse.Tot.Base.parser k t -> f: (_: t -> Prims.bool) -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Tot.Combinators.parse_filter p f) input == ((match LowParse.Spec.Base.parse p input with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) -> (match f x with | true -> FStar.Pervasives.Native.Some (x, consumed) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (LowParse.Spec.Combinators.parse_filter_refine f * LowParse.Spec.Base.consumed_length input)) <: FStar.Pervasives.Native.option (LowParse.Spec.Combinators.parse_filter_refine f * LowParse.Spec.Base.consumed_length input)))

FStar.Pervasives.Lemma

val nondep_then_eq (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) (b: bytes) : Lemma (parse (nondep_then p1 p2) b == (match parse p1 b with | Some (x1, consumed1) -> let b' = Seq.slice b consumed1 (Seq.length b) in begin match parse p2 b' with | Some (x2, consumed2) -> Some ((x1, x2), consumed1 + consumed2) | _ -> None end | _ -> None ))

let nondep_then_eq #k1 #t1 p1 #k2 #t2 p2 b = nondep_then_eq #k1 p1 #k2 p2 b

val nondep_then_eq (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) (b: bytes) : Lemma (parse (nondep_then p1 p2) b == (match parse p1 b with | Some (x1, consumed1) -> let b' = Seq.slice b consumed1 (Seq.length b) in begin match parse p2 b' with | Some (x2, consumed2) -> Some ((x1, x2), consumed1 + consumed2) | _ -> None end | _ -> None )) let nondep_then_eq #k1 #t1 p1 #k2 #t2 p2 b =

nondep_then_eq #k1 p1 #k2 p2 b

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end )) let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input = parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input val serialize_tagged_union (#kt: parser_kind) (#tag_t: Type) (#pt: parser kt tag_t) (st: serializer pt) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (#p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (s: (t: tag_t) -> Tot (serializer (p t))) : Pure (serializer (parse_tagged_union pt tag_of_data p)) (requires (kt.parser_kind_subkind == Some ParserStrong)) (ensures (fun _ -> True)) let serialize_tagged_union #kt st tag_of_data #k s = serialize_tot_tagged_union #kt st tag_of_data #k s val nondep_then (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) : Tot (parser (and_then_kind k1 k2) (t1 * t2)) let nondep_then #k1 = tot_nondep_then #k1 val nondep_then_eq (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) (b: bytes) : Lemma (parse (nondep_then p1 p2) b == (match parse p1 b with | Some (x1, consumed1) -> let b' = Seq.slice b consumed1 (Seq.length b) in begin match parse p2 b' with | Some (x2, consumed2) -> Some ((x1, x2), consumed1 + consumed2) | _ -> None end | _ -> None ))

LowParse.Tot.Combinators.fst

val nondep_then_eq (#k1: parser_kind) (#t1: Type) (p1: parser k1 t1) (#k2: parser_kind) (#t2: Type) (p2: parser k2 t2) (b: bytes) : Lemma (parse (nondep_then p1 p2) b == (match parse p1 b with | Some (x1, consumed1) -> let b' = Seq.slice b consumed1 (Seq.length b) in begin match parse p2 b' with | Some (x2, consumed2) -> Some ((x1, x2), consumed1 + consumed2) | _ -> None end | _ -> None ))

LowParse.Tot.Combinators.nondep_then_eq

p1: LowParse.Tot.Base.parser k1 t1 -> p2: LowParse.Tot.Base.parser k2 t2 -> b: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Tot.Combinators.nondep_then p1 p2) b == ((match LowParse.Spec.Base.parse p1 b with | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x1 consumed1) -> let b' = FStar.Seq.Base.slice b consumed1 (FStar.Seq.Base.length b) in (match LowParse.Spec.Base.parse p2 b' with | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x2 consumed2) -> FStar.Pervasives.Native.Some (FStar.Pervasives.Native.Mktuple2 x1 x2, consumed1 + consumed2) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option ((t1 * t2) * LowParse.Spec.Base.consumed_length b) | _ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option ((t1 * t2) * LowParse.Spec.Base.consumed_length b)))

FStar.Pervasives.Lemma

val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end ))

let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input = parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input

val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end )) let parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input =

parse_tagged_union_eq #kt #tag_t pt #data_t tag_of_data #k p input

module LowParse.Tot.Combinators include LowParse.Spec.Combinators include LowParse.Tot.Base inline_for_extraction let fail_parser = tot_fail_parser inline_for_extraction let parse_ret = tot_parse_ret inline_for_extraction let parse_empty : parser parse_ret_kind unit = parse_ret () inline_for_extraction let parse_synth #k #t1 #t2 = tot_parse_synth #k #t1 #t2 val parse_synth_eq (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: parser k t1) (f2: t1 -> Tot t2) (b: bytes) : Lemma (requires (synth_injective f2)) (ensures (parse (parse_synth p1 f2) b == parse_synth' #k p1 f2 b)) let parse_synth_eq #k #t1 #t2 = tot_parse_synth_eq #k #t1 #t2 val serialize_synth (#k: parser_kind) (#t1: Type) (#t2: Type) (p1: tot_parser k t1) (f2: t1 -> Tot t2) (s1: serializer p1) (g1: t2 -> GTot t1) (u: unit { synth_inverse f2 g1 /\ synth_injective f2 }) : Tot (serializer (tot_parse_synth p1 f2)) let serialize_synth #k #t1 #t2 = serialize_tot_synth #k #t1 #t2 let serialize_weaken (#k: parser_kind) (#t: Type) (k' : parser_kind) (#p: parser k t) (s: serializer p { k' `is_weaker_than` k }) : Tot (serializer (weaken k' p)) = serialize_weaken #k k' s inline_for_extraction let parse_filter #k #t = tot_parse_filter #k #t val parse_filter_eq (#k: parser_kind) (#t: Type) (p: parser k t) (f: (t -> Tot bool)) (input: bytes) : Lemma (parse (parse_filter p f) input == (match parse p input with | None -> None | Some (x, consumed) -> if f x then Some (x, consumed) else None )) let parse_filter_eq #k #t = tot_parse_filter_eq #k #t let serialize_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (f: (t -> Tot bool)) : Tot (serializer (parse_filter p f)) = Classical.forall_intro (parse_filter_eq #k #t p f); serialize_ext _ (serialize_filter s f) _ inline_for_extraction let and_then #k #t = tot_and_then #k #t val and_then_eq (#k: parser_kind) (#t:Type) (p: parser k t) (#k': parser_kind) (#t':Type) (p': (t -> Tot (parser k' t'))) (input: bytes) : Lemma (requires (and_then_cases_injective p')) (ensures (parse (and_then p p') input == and_then_bare p p' input)) let and_then_eq #k #t p #k' #t' p' input = and_then_eq #k #t p #k' #t' p' input inline_for_extraction val parse_tagged_union_payload (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (tg: tag_t) : Tot (parser k data_t) let parse_tagged_union_payload #tag_t #data_t = tot_parse_tagged_union_payload #tag_t #data_t inline_for_extraction val parse_tagged_union (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Tot (parser (and_then_kind kt k) data_t) let parse_tagged_union #kt #tag_t = tot_parse_tagged_union #kt #tag_t let parse_tagged_union_payload_and_then_cases_injective (#tag_t: Type) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) : Lemma (and_then_cases_injective (parse_tagged_union_payload tag_of_data p)) = parse_tagged_union_payload_and_then_cases_injective tag_of_data #k p val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end ))

LowParse.Tot.Combinators.fst

val parse_tagged_union_eq (#kt: parser_kind) (#tag_t: Type) (pt: parser kt tag_t) (#data_t: Type) (tag_of_data: (data_t -> Tot tag_t)) (#k: parser_kind) (p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t))) (input: bytes) : Lemma (parse (parse_tagged_union pt tag_of_data p) input == (match parse pt input with | None -> None | Some (tg, consumed_tg) -> let input_tg = Seq.slice input consumed_tg (Seq.length input) in begin match parse (p tg) input_tg with | Some (x, consumed_x) -> Some ((x <: data_t), consumed_tg + consumed_x) | None -> None end ))

LowParse.Tot.Combinators.parse_tagged_union_eq

pt: LowParse.Tot.Base.parser kt tag_t -> tag_of_data: (_: data_t -> tag_t) -> p: (t: tag_t -> LowParse.Tot.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) -> input: LowParse.Bytes.bytes -> FStar.Pervasives.Lemma (ensures LowParse.Spec.Base.parse (LowParse.Tot.Combinators.parse_tagged_union pt tag_of_data p) input == ((match LowParse.Spec.Base.parse pt input with | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ tg consumed_tg) -> let input_tg = FStar.Seq.Base.slice input consumed_tg (FStar.Seq.Base.length input) in (match LowParse.Spec.Base.parse (p tg) input_tg with | FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) -> FStar.Pervasives.Native.Some (x, consumed_tg + consumed_x) | FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None) <: FStar.Pervasives.Native.option (data_t * LowParse.Spec.Base.consumed_length input)) <: FStar.Pervasives.Native.option (data_t * LowParse.Spec.Base.consumed_length input)))

Prims.Tot

let aff_point_mul = S.aff_point_mul

let aff_point_mul =

S.aff_point_mul

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee

Hacl.Spec.K256.GLV.fst

val aff_point_mul : a: Prims.nat -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point

Hacl.Spec.K256.GLV.aff_point_mul

a: Prims.nat -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point

Prims.Tot

val aff_point_negate_cond (p: S.aff_point) (is_negate: bool) : S.aff_point

let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p

val aff_point_negate_cond (p: S.aff_point) (is_negate: bool) : S.aff_point let aff_point_negate_cond (p: S.aff_point) (is_negate: bool) : S.aff_point =

if is_negate then S.aff_point_negate p else p

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *)

Hacl.Spec.K256.GLV.fst

val aff_point_negate_cond (p: S.aff_point) (is_negate: bool) : S.aff_point

Hacl.Spec.K256.GLV.aff_point_negate_cond

p: Spec.K256.PointOps.aff_point -> is_negate: Prims.bool -> Spec.K256.PointOps.aff_point

Prims.Tot

val point_negate_cond (p: S.proj_point) (is_negate: bool) : S.proj_point

let point_negate_cond (p:S.proj_point) (is_negate:bool) : S.proj_point = if is_negate then S.point_negate p else p

val point_negate_cond (p: S.proj_point) (is_negate: bool) : S.proj_point let point_negate_cond (p: S.proj_point) (is_negate: bool) : S.proj_point =

if is_negate then S.point_negate p else p

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p // https://github.com/bitcoin-core/secp256k1/blob/master/src/ecmult_impl.h // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point = let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2) // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) // which can be computed as a double exponentiation ([a]P + [b]Q) let aff_point_mul_endo_split (k:S.qelem) (p:S.aff_point) : S.aff_point = let r1, p1, r2, p2 = aff_ecmult_endo_split k p in S.aff_point_add (aff_point_mul r1 p1) (aff_point_mul r2 p2) (** Fast computation of [k]P in projective coordinates *)

Hacl.Spec.K256.GLV.fst

val point_negate_cond (p: S.proj_point) (is_negate: bool) : S.proj_point

Hacl.Spec.K256.GLV.point_negate_cond

p: Spec.K256.PointOps.proj_point -> is_negate: Prims.bool -> Spec.K256.PointOps.proj_point

Prims.Tot

val aff_point_mul_lambda (p: S.aff_point) : S.aff_point

let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py)

val aff_point_mul_lambda (p: S.aff_point) : S.aff_point let aff_point_mul_lambda (p: S.aff_point) : S.aff_point =

let px, py = p in (S.(beta *% px), py)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul

Hacl.Spec.K256.GLV.fst

val aff_point_mul_lambda (p: S.aff_point) : S.aff_point

Hacl.Spec.K256.GLV.aff_point_mul_lambda

p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point

Prims.Tot

val aff_ecmult_endo_split (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point

let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point = let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2)

val aff_ecmult_endo_split (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point let aff_ecmult_endo_split (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point =

let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p // https://github.com/bitcoin-core/secp256k1/blob/master/src/ecmult_impl.h // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) :

Hacl.Spec.K256.GLV.fst

val aff_ecmult_endo_split (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point

Hacl.Spec.K256.GLV.aff_ecmult_endo_split

k: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.aff_point -> ((Spec.K256.PointOps.qelem * Spec.K256.PointOps.aff_point) * Spec.K256.PointOps.qelem) * Spec.K256.PointOps.aff_point

Prims.Tot

val aff_negate_point_and_scalar_cond (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point

let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p

val aff_negate_point_and_scalar_cond (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point let aff_negate_point_and_scalar_cond (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point =

if S.scalar_is_high k then let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg else k, p

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p

Hacl.Spec.K256.GLV.fst

val aff_negate_point_and_scalar_cond (k: S.qelem) (p: S.aff_point) : S.qelem & S.aff_point

Hacl.Spec.K256.GLV.aff_negate_point_and_scalar_cond

k: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.qelem * Spec.K256.PointOps.aff_point

Prims.Tot

val aff_point_mul_endo_split (k: S.qelem) (p: S.aff_point) : S.aff_point

let aff_point_mul_endo_split (k:S.qelem) (p:S.aff_point) : S.aff_point = let r1, p1, r2, p2 = aff_ecmult_endo_split k p in S.aff_point_add (aff_point_mul r1 p1) (aff_point_mul r2 p2)

val aff_point_mul_endo_split (k: S.qelem) (p: S.aff_point) : S.aff_point let aff_point_mul_endo_split (k: S.qelem) (p: S.aff_point) : S.aff_point =

let r1, p1, r2, p2 = aff_ecmult_endo_split k p in S.aff_point_add (aff_point_mul r1 p1) (aff_point_mul r2 p2)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p // https://github.com/bitcoin-core/secp256k1/blob/master/src/ecmult_impl.h // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point = let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2) // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y)

Hacl.Spec.K256.GLV.fst

val aff_point_mul_endo_split (k: S.qelem) (p: S.aff_point) : S.aff_point

Hacl.Spec.K256.GLV.aff_point_mul_endo_split

k: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.aff_point -> Spec.K256.PointOps.aff_point

Prims.Tot

val ecmult_endo_split (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point & S.qelem & S.proj_point

let ecmult_endo_split (k:S.qelem) (p:S.proj_point) : S.qelem & S.proj_point & S.qelem & S.proj_point = let r1, r2 = scalar_split_lambda k in let lambda_p = point_mul_lambda p in let r1, p1 = negate_point_and_scalar_cond r1 p in let r2, p2 = negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2)

val ecmult_endo_split (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point & S.qelem & S.proj_point let ecmult_endo_split (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point & S.qelem & S.proj_point =

let r1, r2 = scalar_split_lambda k in let lambda_p = point_mul_lambda p in let r1, p1 = negate_point_and_scalar_cond r1 p in let r2, p2 = negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p // https://github.com/bitcoin-core/secp256k1/blob/master/src/ecmult_impl.h // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point = let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2) // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) // which can be computed as a double exponentiation ([a]P + [b]Q) let aff_point_mul_endo_split (k:S.qelem) (p:S.aff_point) : S.aff_point = let r1, p1, r2, p2 = aff_ecmult_endo_split k p in S.aff_point_add (aff_point_mul r1 p1) (aff_point_mul r2 p2) (** Fast computation of [k]P in projective coordinates *) let point_negate_cond (p:S.proj_point) (is_negate:bool) : S.proj_point = if is_negate then S.point_negate p else p let negate_point_and_scalar_cond (k:S.qelem) (p:S.proj_point) : S.qelem & S.proj_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.point_negate p in k_neg, p_neg end else k, p let ecmult_endo_split (k:S.qelem) (p:S.proj_point) :

Hacl.Spec.K256.GLV.fst

val ecmult_endo_split (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point & S.qelem & S.proj_point

Hacl.Spec.K256.GLV.ecmult_endo_split

k: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.proj_point -> ((Spec.K256.PointOps.qelem * Spec.K256.PointOps.proj_point) * Spec.K256.PointOps.qelem) * Spec.K256.PointOps.proj_point

Prims.Tot

val point_mul_lambda (p: S.proj_point) : S.proj_point

let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z)

val point_mul_lambda (p: S.proj_point) : S.proj_point let point_mul_lambda (p: S.proj_point) : S.proj_point =

let _X, _Y, _Z = p in (S.(beta *% _X), _Y, _Z)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py)

Hacl.Spec.K256.GLV.fst

val point_mul_lambda (p: S.proj_point) : S.proj_point

Hacl.Spec.K256.GLV.point_mul_lambda

p: Spec.K256.PointOps.proj_point -> Spec.K256.PointOps.proj_point

Prims.Tot

val negate_point_and_scalar_cond (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point

let negate_point_and_scalar_cond (k:S.qelem) (p:S.proj_point) : S.qelem & S.proj_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.point_negate p in k_neg, p_neg end else k, p

val negate_point_and_scalar_cond (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point let negate_point_and_scalar_cond (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point =

if S.scalar_is_high k then let k_neg = S.qnegate k in let p_neg = S.point_negate p in k_neg, p_neg else k, p

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q) let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2 (** Fast computation of [k]P in affine coordinates *) let aff_point_negate_cond (p:S.aff_point) (is_negate:bool) : S.aff_point = if is_negate then S.aff_point_negate p else p let aff_negate_point_and_scalar_cond (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point = if S.scalar_is_high k then begin let k_neg = S.qnegate k in let p_neg = S.aff_point_negate p in k_neg, p_neg end else k, p // https://github.com/bitcoin-core/secp256k1/blob/master/src/ecmult_impl.h // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) let aff_ecmult_endo_split (k:S.qelem) (p:S.aff_point) : S.qelem & S.aff_point & S.qelem & S.aff_point = let r1, r2 = scalar_split_lambda k in let lambda_p = aff_point_mul_lambda p in let r1, p1 = aff_negate_point_and_scalar_cond r1 p in let r2, p2 = aff_negate_point_and_scalar_cond r2 lambda_p in (r1, p1, r2, p2) // [k]P = [r1 + r2 * lambda]P = [r1]P + [r2]([lambda]P) = [r1](x,y) + [r2](beta*x,y) // which can be computed as a double exponentiation ([a]P + [b]Q) let aff_point_mul_endo_split (k:S.qelem) (p:S.aff_point) : S.aff_point = let r1, p1, r2, p2 = aff_ecmult_endo_split k p in S.aff_point_add (aff_point_mul r1 p1) (aff_point_mul r2 p2) (** Fast computation of [k]P in projective coordinates *) let point_negate_cond (p:S.proj_point) (is_negate:bool) : S.proj_point = if is_negate then S.point_negate p else p

Hacl.Spec.K256.GLV.fst

val negate_point_and_scalar_cond (k: S.qelem) (p: S.proj_point) : S.qelem & S.proj_point

Hacl.Spec.K256.GLV.negate_point_and_scalar_cond

k: Spec.K256.PointOps.qelem -> p: Spec.K256.PointOps.proj_point -> Spec.K256.PointOps.qelem * Spec.K256.PointOps.proj_point

Prims.Tot

val beta:S.felem

let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee

val beta:S.felem let beta:S.felem =

0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72

Hacl.Spec.K256.GLV.fst

val beta:S.felem

Hacl.Spec.K256.GLV.beta

Spec.K256.PointOps.felem

Prims.Tot

val minus_lambda:S.qelem

let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x

val minus_lambda:S.qelem let minus_lambda:S.qelem =

let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15

Hacl.Spec.K256.GLV.fst

val minus_lambda:S.qelem

Hacl.Spec.K256.GLV.minus_lambda

Spec.K256.PointOps.qelem

Prims.Tot

val lambda:S.qelem

let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72

val lambda:S.qelem let lambda:S.qelem =

0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *)

Hacl.Spec.K256.GLV.fst

val lambda:S.qelem

Hacl.Spec.K256.GLV.lambda

Spec.K256.PointOps.qelem

Prims.Tot

let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2)

let qmul_shift_384 a b =

a * b / pow2 384 + (a * b / pow2 383 % 2)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x

Hacl.Spec.K256.GLV.fst

val qmul_shift_384 : a: Prims.int -> b: Prims.int -> Prims.int

Hacl.Spec.K256.GLV.qmul_shift_384

a: Prims.int -> b: Prims.int -> Prims.int

Prims.Tot

val a1:S.qelem

let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15

val a1:S.qelem let a1:S.qelem =

0x3086d221a7d46bcde86c90e49284eb15

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *)

Hacl.Spec.K256.GLV.fst

val a1:S.qelem

Hacl.Spec.K256.GLV.a1

Spec.K256.PointOps.qelem

Prims.Tot

val minus_b2:S.qelem

let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x

val minus_b2:S.qelem let minus_b2:S.qelem =

let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x

Hacl.Spec.K256.GLV.fst

val minus_b2:S.qelem

Hacl.Spec.K256.GLV.minus_b2

Spec.K256.PointOps.qelem

Prims.Tot

val a2:S.qelem

let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8

val a2:S.qelem let a2:S.qelem =

0x114ca50f7a8e2f3f657c1108d9d44cfd8

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15

Hacl.Spec.K256.GLV.fst

val a2:S.qelem

Hacl.Spec.K256.GLV.a2

Spec.K256.PointOps.qelem

Prims.Tot

val b1:S.qelem

let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x

val b1:S.qelem let b1:S.qelem =

let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x

Hacl.Spec.K256.GLV.fst

val b1:S.qelem

Hacl.Spec.K256.GLV.b1

Spec.K256.PointOps.qelem

Prims.Tot

val minus_b1:S.qelem

let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3

val minus_b1:S.qelem let minus_b1:S.qelem =

0xe4437ed6010e88286f547fa90abfe4c3

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *)

Hacl.Spec.K256.GLV.fst

val minus_b1:S.qelem

Hacl.Spec.K256.GLV.minus_b1

Spec.K256.PointOps.qelem

Prims.Tot

val b2:S.qelem

let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15

val b2:S.qelem let b2:S.qelem =

0x3086d221a7d46bcde86c90e49284eb15

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3

Hacl.Spec.K256.GLV.fst

val b2:S.qelem

Hacl.Spec.K256.GLV.b2

Spec.K256.PointOps.qelem

FStar.Pervasives.Lemma

val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q)

let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q)

val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b =

assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q)

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q)

Hacl.Spec.K256.GLV.fst

val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q)

Hacl.Spec.K256.GLV.qmul_shift_384_lemma

a: Spec.K256.PointOps.qelem -> b: Spec.K256.PointOps.qelem -> FStar.Pervasives.Lemma (ensures Hacl.Spec.K256.GLV.qmul_shift_384 a b < Spec.K256.PointOps.q)

Prims.Tot

val g1:S.qelem

let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x

val g1:S.qelem let g1:S.qelem =

let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x

Hacl.Spec.K256.GLV.fst

val g1:S.qelem

Hacl.Spec.K256.GLV.g1

Spec.K256.PointOps.qelem

Prims.Tot

val g2:S.qelem

let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x

val g2:S.qelem let g2:S.qelem =

let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x

Hacl.Spec.K256.GLV.fst

val g2:S.qelem

Hacl.Spec.K256.GLV.g2

Spec.K256.PointOps.qelem

Prims.Tot

val scalar_split_lambda (k: S.qelem) : S.qelem & S.qelem

let scalar_split_lambda (k:S.qelem) : S.qelem & S.qelem = qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1 : S.qelem = qmul_shift_384 k g1 in let c2 : S.qelem = qmul_shift_384 k g2 in let c1 = S.(c1 *^ minus_b1) in let c2 = S.(c2 *^ minus_b2) in let r2 = S.(c1 +^ c2) in let r1 = S.(k +^ r2 *^ minus_lambda) in r1, r2

val scalar_split_lambda (k: S.qelem) : S.qelem & S.qelem let scalar_split_lambda (k: S.qelem) : S.qelem & S.qelem =

qmul_shift_384_lemma k g1; qmul_shift_384_lemma k g2; let c1:S.qelem = qmul_shift_384 k g1 in let c2:S.qelem = qmul_shift_384 k g2 in let c1 = let open S in c1 *^ minus_b1 in let c2 = let open S in c2 *^ minus_b2 in let r2 = let open S in c1 +^ c2 in let r1 = let open S in k +^ r2 *^ minus_lambda in r1, r2

module Hacl.Spec.K256.GLV open FStar.Mul module S = Spec.K256 #set-options "--z3rlimit 50 --fuel 0 --ifuel 0" (** This module implements the following two functions from libsecp256k1: secp256k1_scalar_split_lambda [1] and secp256k1_ecmult_endo_split [2]. For the secp256k1 curve, we can replace the EC scalar multiplication by `lambda` with one modular multiplication by `beta`: [lambda](px, py) = (beta *% px, py) for any point on the curve P = (px, py), where `lambda` and `beta` are primitive cube roots of unity and can be fixed for the curve. The main idea is to slit a 256-bit scalar k into k1 and k2 s.t. k = (k1 + lambda * k2) % q, where k1 and k2 are 128-bit numbers: [k]P = [(k1 + lambda * k2) % q]P = [k1]P + [k2]([lambda]P) = [k1](px, py) + [k2](beta *% px, py). Using a double fixed-window method, we can save 128 point_double: | before | after ---------------------------------------------------------------------- point_double | 256 | 128 point_add | 256 / 5 = 51 | 128 / 5 + 128 / 5 + 1 = 25 + 25 + 1 = 51 Note that one precomputed table is enough for [k]P, as [r_small]([lambda]P) can be obtained via [r_small]P. [1]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/scalar_impl.h#L123 [2]https://github.com/bitcoin-core/secp256k1/blob/a43e982bca580f4fba19d7ffaf9b5ee3f51641cb/src/ecmult_impl.h#L618 *) (** Fast computation of [lambda]P as (beta * x, y) in affine and projective coordinates *) let lambda : S.qelem = 0x5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72 let beta : S.felem = 0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee // [a]P in affine coordinates let aff_point_mul = S.aff_point_mul // fast computation of [lambda]P in affine coordinates let aff_point_mul_lambda (p:S.aff_point) : S.aff_point = let (px, py) = p in (S.(beta *% px), py) // fast computation of [lambda]P in projective coordinates let point_mul_lambda (p:S.proj_point) : S.proj_point = let (_X, _Y, _Z) = p in (S.(beta *% _X), _Y, _Z) (** Representing a scalar k as (r1 + r2 * lambda) mod S.q, s.t. r1 and r2 are ~128 bits long *) let a1 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_b1 : S.qelem = 0xe4437ed6010e88286f547fa90abfe4c3 let a2 : S.qelem = 0x114ca50f7a8e2f3f657c1108d9d44cfd8 let b2 : S.qelem = 0x3086d221a7d46bcde86c90e49284eb15 let minus_lambda : S.qelem = let x = 0xac9c52b33fa3cf1f5ad9e3fd77ed9ba4a880b9fc8ec739c2e0cfc810b51283cf in assert_norm (x = (- lambda) % S.q); x let b1 : S.qelem = let x = 0xfffffffffffffffffffffffffffffffdd66b5e10ae3a1813507ddee3c5765c7e in assert_norm (x = (- minus_b1) % S.q); x let minus_b2 : S.qelem = let x = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE8A280AC50774346DD765CDA83DB1562C in assert_norm (x = (- b2) % S.q); x let g1 : S.qelem = let x = 0x3086D221A7D46BCDE86C90E49284EB153DAA8A1471E8CA7FE893209A45DBB031 in assert_norm (pow2 384 * b2 / S.q + 1 = x); x let g2 : S.qelem = let x = 0xE4437ED6010E88286F547FA90ABFE4C4221208AC9DF506C61571B4AE8AC47F71 in assert_norm (pow2 384 * minus_b1 / S.q = x); x let qmul_shift_384 a b = a * b / pow2 384 + (a * b / pow2 383 % 2) val qmul_shift_384_lemma (a b:S.qelem) : Lemma (qmul_shift_384 a b < S.q) let qmul_shift_384_lemma a b = assert_norm (S.q < pow2 256); Math.Lemmas.lemma_mult_lt_sqr a b (pow2 256); Math.Lemmas.pow2_plus 256 256; assert (a * b < pow2 512); Math.Lemmas.lemma_div_lt_nat (a * b) 512 384; assert (a * b / pow2 384 < pow2 128); assert_norm (pow2 128 < S.q)

Hacl.Spec.K256.GLV.fst

val scalar_split_lambda (k: S.qelem) : S.qelem & S.qelem

Hacl.Spec.K256.GLV.scalar_split_lambda

k: Spec.K256.PointOps.qelem -> Spec.K256.PointOps.qelem * Spec.K256.PointOps.qelem