effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec uses_rax (#n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) =
match args with
| [] -> false
| a::q -> if of_arg i = rRax then true else uses_rax q (i+1) of_arg | let rec uses_rax
(#n: nat)
(args: list td)
(i: nat{i + List.length args = n})
(of_arg: (reg_nat n -> reg_64))
= | false | null | false | match args with
| [] -> false
| a :: q -> if of_arg i = rRax then true else uses_rax q (i + 1) of_arg | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Vale.X64.Machine_s.rRax",
"Prims.bool",
"Vale.X64.Print_Inline_s.uses_rax"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n"
let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1)
(* Overriding printer for formatting instructions *)
let print_ins (ins:ins) (p:P.printer) : string =
match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\""
let rec print_block (b:codes) (n:int) (p:P.printer) : string & int =
match b with
| Nil -> "", n
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins (Instr _ _ (AnnotateComment s)) :: tail ->
let head_str = " // " ^ s ^ "\n" in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins i :: tail ->
let head_str = print_ins i p in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateNewline _)) :: tail ->
let rest, n' = print_block tail n p in
"\n" ^ rest, n'
| head :: tail ->
let head_str, n' = print_code head n p in
let rest, n'' = print_block tail n' p in
head_str ^ rest, n''
and print_code (c:code) (n:int) (p:P.printer) : string & int =
match c with
| Ins ins -> (print_ins ins p ^ "\n", n)
| Block b -> print_block b n p
| IfElse cond true_code false_code ->
let n1 = n in
let n2 = n + 1 in
let cmp = print_cmp (P.cmp_not cond) n1 p in
let true_str, n' = print_code true_code (n + 2) p in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"L" ^ string_of_int n1 ^ ":\"\n" in
let false_str, n' = print_code false_code n' p in
let label2 = " \"L" ^ string_of_int n2 ^ ":\"\n" in
cmp ^ true_str ^ jmp ^ label1 ^ false_str ^ label2, n'
| While cond body ->
let n1 = n in
let n2 = n + 1 in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n1 ^ ":\"\n" in
let body_str, n' = print_code body (n + 2) p in
let label2 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n2 ^ ":\"\n" in
let cmp = print_cmp cond n1 p in
jmp ^ label1 ^ body_str ^ label2 ^ cmp, n'
let rec print_fn_comments = function
| [] -> ""
| hd::tl -> "// " ^ hd ^ "\n" ^ print_fn_comments tl
let rec remove_blank (c:code) : code =
match c with
| Ins _ -> c
| Block b -> Block (remove_blanks b)
| IfElse cond ct cf -> IfElse cond (remove_blank ct) (remove_blank cf)
| While cond cb -> While cond (remove_blank cb)
and remove_blanks (b:codes) : codes =
match b with
| [] -> []
| Ins (Instr _ _ (AnnotateGhost _)) :: cs -> remove_blanks cs
| Block b :: cs ->
(
match remove_blanks b with
| [] -> remove_blanks cs
| b -> Block b :: remove_blanks cs
)
| c :: cs -> c :: remove_blanks cs
// Check if any argument is passed in the rax register | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val uses_rax : args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{i + FStar.List.Tot.Base.length args = n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64)
-> Prims.bool | [
"recursion"
] | Vale.X64.Print_Inline_s.uses_rax | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{i + FStar.List.Tot.Base.length args = n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64)
-> Prims.bool | {
"end_col": 69,
"end_line": 326,
"start_col": 2,
"start_line": 324
} |
|
Prims.Tot | val remove_blanks (b: codes) : codes | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec remove_blank (c:code) : code =
match c with
| Ins _ -> c
| Block b -> Block (remove_blanks b)
| IfElse cond ct cf -> IfElse cond (remove_blank ct) (remove_blank cf)
| While cond cb -> While cond (remove_blank cb)
and remove_blanks (b:codes) : codes =
match b with
| [] -> []
| Ins (Instr _ _ (AnnotateGhost _)) :: cs -> remove_blanks cs
| Block b :: cs ->
(
match remove_blanks b with
| [] -> remove_blanks cs
| b -> Block b :: remove_blanks cs
)
| c :: cs -> c :: remove_blanks cs | val remove_blanks (b: codes) : codes
let rec remove_blanks (b: codes) : codes = | false | null | false | match b with
| [] -> []
| Ins (Instr _ _ (AnnotateGhost _)) :: cs -> remove_blanks cs
| Block b :: cs ->
(match remove_blanks b with
| [] -> remove_blanks cs
| b -> Block b :: remove_blanks cs)
| c :: cs -> c :: remove_blanks cs | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Vale.X64.Machine_Semantics_s.codes",
"Prims.Nil",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Ghost",
"Prims.list",
"Vale.X64.Print_Inline_s.remove_blanks",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Bytes_Code_s.ocmp",
"Prims.Cons",
"Vale.X64.Machine_s.Block"
] | [
"remove_blank",
"remove_blanks"
] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n"
let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1)
(* Overriding printer for formatting instructions *)
let print_ins (ins:ins) (p:P.printer) : string =
match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\""
let rec print_block (b:codes) (n:int) (p:P.printer) : string & int =
match b with
| Nil -> "", n
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins (Instr _ _ (AnnotateComment s)) :: tail ->
let head_str = " // " ^ s ^ "\n" in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins i :: tail ->
let head_str = print_ins i p in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateNewline _)) :: tail ->
let rest, n' = print_block tail n p in
"\n" ^ rest, n'
| head :: tail ->
let head_str, n' = print_code head n p in
let rest, n'' = print_block tail n' p in
head_str ^ rest, n''
and print_code (c:code) (n:int) (p:P.printer) : string & int =
match c with
| Ins ins -> (print_ins ins p ^ "\n", n)
| Block b -> print_block b n p
| IfElse cond true_code false_code ->
let n1 = n in
let n2 = n + 1 in
let cmp = print_cmp (P.cmp_not cond) n1 p in
let true_str, n' = print_code true_code (n + 2) p in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"L" ^ string_of_int n1 ^ ":\"\n" in
let false_str, n' = print_code false_code n' p in
let label2 = " \"L" ^ string_of_int n2 ^ ":\"\n" in
cmp ^ true_str ^ jmp ^ label1 ^ false_str ^ label2, n'
| While cond body ->
let n1 = n in
let n2 = n + 1 in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n1 ^ ":\"\n" in
let body_str, n' = print_code body (n + 2) p in
let label2 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n2 ^ ":\"\n" in
let cmp = print_cmp cond n1 p in
jmp ^ label1 ^ body_str ^ label2 ^ cmp, n'
let rec print_fn_comments = function
| [] -> ""
| hd::tl -> "// " ^ hd ^ "\n" ^ print_fn_comments tl
let rec remove_blank (c:code) : code =
match c with
| Ins _ -> c
| Block b -> Block (remove_blanks b)
| IfElse cond ct cf -> IfElse cond (remove_blank ct) (remove_blank cf)
| While cond cb -> While cond (remove_blank cb) | false | true | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val remove_blanks (b: codes) : codes | [
"mutual recursion"
] | Vale.X64.Print_Inline_s.remove_blanks | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Vale.X64.Machine_Semantics_s.codes -> Vale.X64.Machine_Semantics_s.codes | {
"end_col": 36,
"end_line": 320,
"start_col": 2,
"start_line": 311
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter | let rec get_nonmodified_input_strings
(n: nat)
(of_arg: (reg_nat n -> reg_64))
(regs_mod reserved_regs: (reg_64 -> bool))
(args: list td)
(i: nat{List.Tot.length args + i <= n})
(reg_names: (reg_64 -> string))
(counter: nat)
(arg_names: (nat -> string))
= | false | null | false | match args with
| [] -> [], reg_names, counter
| a :: q ->
let input, reg_names, counter =
print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names
in
let inputs, reg_names, counter =
get_nonmodified_input_strings n
of_arg
regs_mod
reserved_regs
q
(i + 1)
reg_names
counter
arg_names
in
input @ inputs, reg_names, counter | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"Prims.string",
"FStar.Pervasives.Native.Mktuple3",
"Prims.Nil",
"FStar.List.Tot.Base.op_At",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.Print_Inline_s.get_nonmodified_input_strings",
"Vale.X64.Print_Inline_s.print_nonmodified_input"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_nonmodified_input_strings : n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{FStar.List.Tot.Base.length args + i <= n} ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.list Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | [
"recursion"
] | Vale.X64.Print_Inline_s.get_nonmodified_input_strings | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
reserved_regs: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{FStar.List.Tot.Base.length args + i <= n} ->
reg_names: (_: Vale.X64.Machine_s.reg_64 -> Prims.string) ->
counter: Prims.nat ->
arg_names: (_: Prims.nat -> Prims.string)
-> (Prims.list Prims.string * (_: Vale.X64.Machine_s.reg_64 -> Prims.string)) * Prims.nat | {
"end_col": 38,
"end_line": 168,
"start_col": 4,
"start_line": 163
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str | let rec print_explicit_register_args
(n: nat)
(args: list td)
(i: nat{i + List.length args = n})
(of_arg: (reg_nat n -> reg_64))
(reserved: (reg_64 -> bool))
(names: (nat -> string))
= | false | null | false | match args with
| [] -> false, ""
| a :: q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i + 1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"total"
] | [
"Prims.nat",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Addition",
"FStar.List.Tot.Base.length",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Prims.op_BarBar",
"Prims.op_Hat",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Print_Inline_s.print_explicit_register_args",
"Vale.X64.Print_Inline_s.print_explicit_register_arg"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, "" | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_explicit_register_args : n: Prims.nat ->
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{i + FStar.List.Tot.Base.length args = n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
names: (_: Prims.nat -> Prims.string)
-> Prims.bool * Prims.string | [
"recursion"
] | Vale.X64.Print_Inline_s.print_explicit_register_args | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
n: Prims.nat ->
args: Prims.list Vale.Interop.Base.td ->
i: Prims.nat{i + FStar.List.Tot.Base.length args = n} ->
of_arg: (_: Vale.Interop.X64.reg_nat n -> Vale.X64.Machine_s.reg_64) ->
reserved: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
names: (_: Prims.nat -> Prims.string)
-> Prims.bool * Prims.string | {
"end_col": 57,
"end_line": 223,
"start_col": 2,
"start_line": 218
} |
|
FStar.All.ML | val print_inline
(name: string)
(label: int)
(ret_val: option string)
(n: nat)
(args: list td {List.length args = n})
(arg_names: (nat -> string))
(code: code)
(of_arg: (reg_nat (List.length args) -> reg_64))
(regs_mod: (reg_64 -> bool))
(fn_comments: list string)
: FStar.All.ML int | [
{
"abbrev": true,
"full_module": "Vale.X64.Print_s",
"short_module": "P"
},
{
"abbrev": false,
"full_module": "Vale.Interop.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.IO",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.List.Tot",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_inline
(name:string)
(label:int)
(ret_val:option string)
(n:nat)
(args:list td{List.length args = n})
(arg_names:nat -> string)
(code:code)
(of_arg:reg_nat (List.length args) -> reg_64)
(regs_mod:reg_64 -> bool)
(fn_comments:list string)
: FStar.All.ML int =
let comments = print_fn_comments fn_comments in
let reserved_regs = build_reserved_args code (fun _ -> false) in
let inputs_use_rax = uses_rax args 0 of_arg in
if reserved_regs rRax && Some? ret_val then
FStar.All.failwith "We require the annotation register uint64_t result(rax), but it would be ignored by gcc < 9";
if inputs_use_rax && Some? ret_val then
FStar.All.failwith "inputs are not allowed to be passed in rax when there is a return argument";
// Signature: static inline (void | uint64_t) [name] (arg1, arg2???) {
let header = "static inline " ^ print_rettype ret_val ^ " " ^ name ^ " (" ^ print_args args 0 arg_names ^ ") \n{\n" in
// If we have a return value, declare a variable for it
let ret_reg = print_register_ret reserved_regs ret_val in
// Explicitly allocate registers when needed
let has_explicit, explicit_regs = print_explicit_register_args n args 0 of_arg reserved_regs arg_names in
// Start printing the code, need the __asm__ volatile header
let start_code = (if Some? ret_val || has_explicit then "\n" else "") ^ " __asm__ volatile(\n" in
// Initially, the register names are the same as in assembly
// This function will be modified to address arguments by their number instead of explicitly allocating them
let init_reg_names r = "%" ^ P.print_reg_name r in
// Each *modified* input should be specified as "+r" (name) in the output line
// If we have a return value, it should be written only and specified as "=r" (name)
let output_str, output_reg_names, output_nbr = print_modified_inputs n of_arg regs_mod reserved_regs args ret_val init_reg_names 0 arg_names in
let output_str = " : " ^ output_str in
// Each *non-modified* input should be specified as `"r" (name)` in the input line
let input_str, inlined_reg_names, _ = print_nonmodified_inputs n of_arg regs_mod reserved_regs args output_reg_names output_nbr arg_names in
let input_str = " : " ^ input_str in
// Propagating the "numbered", implicit registers to reg32 and small_reg
let inlined_reg32_names r =
if ("%" ^ P.print_reg_name r) = inlined_reg_names r then "%" ^ P.print_reg32_name r
// In this case, this register is replaced by a number.
// We add the "k" prefix for 32-bit operands
else "k" ^ inlined_reg_names r
in
let inlined_small_reg_names r =
if r > 3 then P.print_small_reg_name r else
if ("%" ^ P.print_reg_name r) = inlined_reg_names r then "%" ^ P.print_small_reg_name r
// In this case, this register is replaced by a number.
// We add the "b" prefix for bytes
else "b" ^ inlined_reg_names r
in
// In inline assembly, operands are prefixed by "%%" instead of "%" in regular GCC assembly
let printer = {P.gcc with
P.print_reg_name = inlined_reg_names;
P.print_reg32_name = inlined_reg32_names;
P.print_small_reg_name = inlined_small_reg_names } in
// The assembly should be compliant with gcc
let (code_str, final_label) = print_code (remove_blank code) label printer in
// Every modified register that wasn't used for the inputs/outputs should be specified in the modified line
let modified_str = " : " ^ print_modified_registers n ret_val of_arg regs_mod reserved_regs args in
let close_code = " );\n" ^ (if Some? ret_val then "\n return " ^ Some?.v ret_val ^ ";\n" else "") ^ "}\n\n" in
print_string (comments ^ header ^ ret_reg ^ explicit_regs ^ start_code ^ code_str ^ output_str ^ input_str ^ modified_str ^ close_code);
final_label | val print_inline
(name: string)
(label: int)
(ret_val: option string)
(n: nat)
(args: list td {List.length args = n})
(arg_names: (nat -> string))
(code: code)
(of_arg: (reg_nat (List.length args) -> reg_64))
(regs_mod: (reg_64 -> bool))
(fn_comments: list string)
: FStar.All.ML int
let print_inline
(name: string)
(label: int)
(ret_val: option string)
(n: nat)
(args: list td {List.length args = n})
(arg_names: (nat -> string))
(code: code)
(of_arg: (reg_nat (List.length args) -> reg_64))
(regs_mod: (reg_64 -> bool))
(fn_comments: list string)
: FStar.All.ML int = | true | null | false | let comments = print_fn_comments fn_comments in
let reserved_regs = build_reserved_args code (fun _ -> false) in
let inputs_use_rax = uses_rax args 0 of_arg in
if reserved_regs rRax && Some? ret_val
then
FStar.All.failwith "We require the annotation register uint64_t result(rax), but it would be ignored by gcc < 9"
;
if inputs_use_rax && Some? ret_val
then FStar.All.failwith "inputs are not allowed to be passed in rax when there is a return argument";
let header =
"static inline " ^
print_rettype ret_val ^ " " ^ name ^ " (" ^ print_args args 0 arg_names ^ ") \n{\n"
in
let ret_reg = print_register_ret reserved_regs ret_val in
let has_explicit, explicit_regs =
print_explicit_register_args n args 0 of_arg reserved_regs arg_names
in
let start_code = (if Some? ret_val || has_explicit then "\n" else "") ^ " __asm__ volatile(\n" in
let init_reg_names r = "%" ^ P.print_reg_name r in
let output_str, output_reg_names, output_nbr =
print_modified_inputs n of_arg regs_mod reserved_regs args ret_val init_reg_names 0 arg_names
in
let output_str = " : " ^ output_str in
let input_str, inlined_reg_names, _ =
print_nonmodified_inputs n
of_arg
regs_mod
reserved_regs
args
output_reg_names
output_nbr
arg_names
in
let input_str = " : " ^ input_str in
let inlined_reg32_names r =
if ("%" ^ P.print_reg_name r) = inlined_reg_names r
then "%" ^ P.print_reg32_name r
else "k" ^ inlined_reg_names r
in
let inlined_small_reg_names r =
if r > 3
then P.print_small_reg_name r
else
if ("%" ^ P.print_reg_name r) = inlined_reg_names r
then "%" ^ P.print_small_reg_name r
else "b" ^ inlined_reg_names r
in
let printer =
{
P.gcc with
P.print_reg_name = inlined_reg_names;
P.print_reg32_name = inlined_reg32_names;
P.print_small_reg_name = inlined_small_reg_names
}
in
let code_str, final_label = print_code (remove_blank code) label printer in
let modified_str = " : " ^ print_modified_registers n ret_val of_arg regs_mod reserved_regs args in
let close_code =
" );\n" ^ (if Some? ret_val then "\n return " ^ Some?.v ret_val ^ ";\n" else "") ^ "}\n\n"
in
print_string (comments ^
header ^
ret_reg ^
explicit_regs ^ start_code ^ code_str ^ output_str ^ input_str ^ modified_str ^ close_code);
final_label | {
"checked_file": "Vale.X64.Print_Inline_s.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Interop.X64.fsti.checked",
"Vale.Interop.Base.fst.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.All.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Print_Inline_s.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.int",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.list",
"Vale.Interop.Base.td",
"Prims.b2t",
"Prims.op_Equality",
"FStar.List.Tot.Base.length",
"Vale.X64.Machine_Semantics_s.code",
"Vale.Interop.X64.reg_nat",
"Vale.X64.Machine_s.reg_64",
"Prims.bool",
"Prims.unit",
"FStar.IO.print_string",
"Prims.op_Hat",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Vale.X64.Print_Inline_s.print_modified_registers",
"FStar.Pervasives.Native.tuple2",
"Vale.X64.Print_Inline_s.print_code",
"Vale.X64.Print_Inline_s.remove_blank",
"Vale.X64.Print_s.printer",
"Vale.X64.Print_s.Mkprinter",
"Vale.X64.Print_s.__proj__Mkprinter__item__reg_prefix",
"Vale.X64.Print_s.gcc",
"Vale.X64.Print_s.__proj__Mkprinter__item__mem_prefix",
"Vale.X64.Print_s.__proj__Mkprinter__item__maddr",
"Vale.X64.Print_s.__proj__Mkprinter__item__const",
"Vale.X64.Print_s.__proj__Mkprinter__item__ins_name",
"Vale.X64.Print_s.__proj__Mkprinter__item__op_order",
"Vale.X64.Print_s.__proj__Mkprinter__item__align",
"Vale.X64.Print_s.__proj__Mkprinter__item__header",
"Vale.X64.Print_s.__proj__Mkprinter__item__footer",
"Vale.X64.Print_s.__proj__Mkprinter__item__proc_name",
"Vale.X64.Print_s.__proj__Mkprinter__item__ret",
"Vale.X64.Print_s.__proj__Mkprinter__item__sha256rnds2_explicit_xmm0",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_LessThan",
"Prims.op_GreaterThan",
"Vale.X64.Print_s.print_small_reg_name",
"Vale.X64.Print_s.print_reg_name",
"Vale.X64.Print_s.print_reg32_name",
"FStar.Pervasives.Native.tuple3",
"Vale.X64.Print_Inline_s.print_nonmodified_inputs",
"Vale.X64.Print_Inline_s.print_modified_inputs",
"Prims.op_BarBar",
"Vale.X64.Print_Inline_s.print_explicit_register_args",
"Vale.X64.Print_Inline_s.print_register_ret",
"Vale.X64.Print_Inline_s.print_rettype",
"Vale.X64.Print_Inline_s.print_args",
"Prims.op_AmpAmp",
"FStar.All.failwith",
"Vale.X64.Machine_s.rRax",
"Vale.X64.Print_Inline_s.uses_rax",
"Vale.X64.Print_Inline_s.build_reserved_args",
"Vale.X64.Print_Inline_s.print_fn_comments"
] | [] | module Vale.X64.Print_Inline_s
open FStar.Mul
open FStar.List.Tot
open Vale.X64.Machine_s
open Vale.X64.Bytes_Code_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Instruction_s
open FStar.IO
open Vale.Interop.Base
open Vale.Interop.X64
module P = Vale.X64.Print_s
let print_rettype (ret_val:option string) = match ret_val with
| None -> "void"
| Some _ -> "uint64_t"
let print_basetype (t:base_typ) = match t with
| TUInt8 -> "uint8_t"
| TUInt16 -> "uint16_t"
| TUInt32 -> "uint32_t"
| TUInt64 -> "uint64_t"
| TUInt128 -> "ERROR"
// Returns "uint8_t arg2" or "uint64_t* arg0" for instance
let print_arg (a:td) (i:nat) (names:nat -> string) = match a with
| TD_Base src -> print_basetype src ^ " " ^ names i
| TD_Buffer src _ _ | TD_ImmBuffer src _ _ -> print_basetype src ^ " *" ^ names i
// Prints a list of args with their types, separated by a comma
let rec print_args (args:list td) (i:nat) (names:nat -> string) = match args with
| [] -> ""
| [a] -> print_arg a i names
| a::q -> print_arg a i names ^ ", " ^ print_args q (i+1) names
let rec build_reserved_args_outs (l:list instr_out) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let (_, op) = hd in
let reserved : (reg_64 -> bool) = (fun r ->
match op with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_outs tl reserved r
let rec build_reserved_args_ins (l:list instr_operand) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r ->
match l with
| [] -> reserved r
| hd::tl ->
let reserved : (reg_64 -> bool) = (fun r ->
match hd with
| IOpIm (IOp64One (OReg reg)) ->
// Implicit register, adding it to "reserved" registers
if r = reg then true else reserved r
| _ -> reserved r)
in build_reserved_args_ins tl reserved r
// Traverses code, looking for instructions implicitly using registers.
// When found, mark such registers as reserved so that they are not used during implicit allocation
let rec build_reserved_args (c:code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases c) =
fun r ->
(match c with
| Ins ins -> begin
match ins with
| Instr i _ _ ->
let reserved = build_reserved_args_outs i.outs reserved in
let reserved = build_reserved_args_ins (InstrTypeRecord?.args i) reserved in
reserved r
| _ -> reserved r
end
| Block l -> (build_reserved_args_block l reserved) r
| IfElse cond ifTrue ifFalse ->
let reservedT = build_reserved_args ifTrue reserved in
build_reserved_args ifFalse reservedT r
| While cond body -> build_reserved_args body reserved r
)
and build_reserved_args_block (l:list code) (reserved:reg_64 -> bool)
: Tot (reg_64 -> bool)
(decreases l) =
fun r -> (
match l with
| [] -> reserved r
| hd::tl ->
let reserved = build_reserved_args hd reserved in
build_reserved_args_block tl reserved r
)
// Prints `"=&r" (name)` if an output is specified
let print_output_ret ret_val (reg_names:reg_64 -> string) (counter:nat) : list string & (reg_64 -> string) & nat
= match ret_val with
| None -> [], reg_names, counter
| Some name -> (["\"=&r\" (" ^ name ^ ")"],
// If r = rax then address it as current arg number
(fun r -> if r = 0 then string_of_int counter else reg_names r),
counter + 1)
// If the register in which a is passed is modified, we should specify `"+&r" (name)`
let print_modified_input
(n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then
(["\"+&r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1
) else ([], reg_names, counter)
// Get a list of strings corresponding to modified inputs
let rec get_modified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{i + List.Tot.length args <= n}) (ret_val:option string)
(reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat
= match args with
| [] -> print_output_ret ret_val reg_names counter
| a::q ->
let output, reg_names, counter = print_modified_input n a i of_arg regs_mod reserved_regs reg_names counter arg_names in
let outputs, reg_names, counter = get_modified_input_strings n of_arg regs_mod reserved_regs q (i+1) ret_val reg_names counter arg_names in
output @ outputs, reg_names, counter
// Print the list of modified inputs, separated by commas
let print_modified_inputs
(n:nat)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n})
(ret_val:option string)
(reg_names:reg_64 -> string)
(counter:nat)
(arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let outputs, output_reg_names, output_nbr = get_modified_input_strings n of_arg regs_mod reserved_regs args 0 ret_val reg_names counter arg_names in
aux outputs, output_reg_names, output_nbr
// If the register in which an arg is passed is not modified, we should specify it as `"r" (name)`
let print_nonmodified_input
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(a:td) (i:nat{i < n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) : list string & (reg_64 -> string) & nat =
if regs_mod (of_arg i) then ([], reg_names, counter) else
(["\"r\" (" ^ arg_names i ^ (if reserved_regs (of_arg i) then "_r)" else ")")],
(fun r -> if r = of_arg i && not (reserved_regs r) then string_of_int counter else reg_names r),
counter + 1)
// Get a list of strings corresponding to modified inputs
let rec get_nonmodified_input_strings
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td) (i:nat{List.Tot.length args + i <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string)
= match args with
| [] -> [], reg_names, counter
| a::q ->
let input, reg_names, counter = print_nonmodified_input n of_arg regs_mod reserved_regs a i reg_names counter arg_names in
let inputs, reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs q (i+1) reg_names counter arg_names in
input @ inputs, reg_names, counter
let print_nonmodified_inputs
(n:nat) (of_arg:reg_nat n -> reg_64) (regs_mod:reg_64 -> bool) (reserved_regs:reg_64 -> bool)
(args:list td{List.Tot.length args <= n}) (reg_names:reg_64 -> string) (counter:nat) (arg_names:nat -> string) =
let rec aux = function
| [] -> "\n"
| [a] -> a ^ "\n"
| a :: q -> a ^ ", " ^ aux q
in
let inputs, input_reg_names, counter = get_nonmodified_input_strings n of_arg regs_mod reserved_regs args 0 reg_names counter arg_names in
aux inputs, input_reg_names, counter
// Print the list of modified registers, + memory and cc
let print_modified_registers
(n:nat)
(ret_val:option string)
(of_arg:reg_nat n -> reg_64)
(regs_mod:reg_64 -> bool)
(reserved_args:reg_64 -> bool)
(args:list td) =
// This register was already specified as output
let output_register a = Some? ret_val && a = rRax in
let rec input_register (i:nat) (a:reg_64) : Tot bool (decreases (n-i)) =
if i >= n then false
else
a = of_arg i // This register was already specified for the i-th argument
|| input_register (i+1) a
in
let rec aux = function
| [] -> "\"memory\", \"cc\"\n"
| a::q ->
// This register is not modified, or was already specified as input or output: we skip it
if not (regs_mod a) || input_register 0 a || output_register a then aux q
// Register not modified or already specified in inputs, we add it
else "\"%" ^ P.print_reg_name a ^ "\", " ^ aux q
in aux [rRax; rRbx; rRcx; rRdx; rRsi; rRdi; rRbp; rRsp; rR8; rR9; rR10; rR11; rR12; rR13; rR14; rR15]
// Prints "register uint64_t *argi_r __asm__("[reg]") = argi;\n"
let print_explicit_register_arg (n:nat) (a:td) (i:nat{i < n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
let ty = match a with
| TD_Base _ -> "uint64_t "
| _ -> "uint64_t *"
in
if reserved (of_arg i) then
// If the associated register is reserved, we really this argument in it. For instance if it is Rdx and we have Mul(x) instructions
true, " register " ^ ty ^ names i ^ "_r __asm__(\"" ^ P.print_reg_name (of_arg i) ^ "\") = " ^ names i ^ ";\n"
else false, ""
let rec print_explicit_register_args (n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) (reserved:reg_64 -> bool) (names:nat -> string) =
match args with
| [] -> false, ""
| a::q ->
let was_explicit, explicit_str = print_explicit_register_arg n a i of_arg reserved names in
let are_explicit, rest_str = print_explicit_register_args n q (i+1) of_arg reserved names in
was_explicit || are_explicit, explicit_str ^ rest_str
// If we have a return parameter with a reserved register, print "register uint64_t [name] __asm__("rax");\n"
let print_register_ret (reserved:reg_64 -> bool) = function
| None -> ""
| Some name -> if reserved rRax then " register uint64_t " ^ name ^ " __asm__(\"rax\");\n" else " uint64_t " ^ name ^ ";\n"
(* This is a copy from X64.Print_s, and should remain in sync. The difference is that
each line should be in quotes, and end by a semicolon in inline assembly *)
let print_cmp (c:ocmp) (counter:int) (p:P.printer) : string =
let print_ops (o1:operand64) (o2:operand64) : string =
let first, second = p.P.op_order (P.print_operand o1 p) (P.print_operand o2 p) in
" cmp " ^ first ^ ", " ^ second ^ "\n"
in
match c with
| OEq o1 o2 -> " \"" ^ print_ops o1 o2 ^ " je " ^ "L" ^ string_of_int counter ^ ";\"\n"
| ONe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jne "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jbe "^ "L" ^ string_of_int counter ^ ";\"\n"
| OGe o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jae "^ "L" ^ string_of_int counter ^ ";\"\n"
| OLt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " jb " ^ "L" ^ string_of_int counter ^ ";\"\n"
| OGt o1 o2 -> " \"" ^ print_ops o1 o2 ^ " ja " ^ "L" ^ string_of_int counter ^ ";\"\n"
let rec print_spaces (n:nat) : string =
match n with
| 0 -> ""
| n -> " " ^ print_spaces (n-1)
(* Overriding printer for formatting instructions *)
let print_ins (ins:ins) (p:P.printer) : string =
match ins with
| Instr _ _ (AnnotateComment s) -> " // " ^ s
| Instr _ _ (AnnotateLargeComment s) -> "\n /////// " ^ s ^ " ////// \n"
| Instr _ _ (AnnotateSpace n) -> print_spaces n
| _ -> " \"" ^ P.print_ins ins p ^ ";\""
let rec print_block (b:codes) (n:int) (p:P.printer) : string & int =
match b with
| Nil -> "", n
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins (Instr _ _ (AnnotateComment s)) :: tail ->
let head_str = " // " ^ s ^ "\n" in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateSpace spaces)) :: Ins i :: tail ->
let head_str = print_ins i p in
let rest, n' = print_block tail n p in
print_spaces spaces ^ head_str ^ rest, n'
| Ins (Instr _ _ (AnnotateNewline _)) :: tail ->
let rest, n' = print_block tail n p in
"\n" ^ rest, n'
| head :: tail ->
let head_str, n' = print_code head n p in
let rest, n'' = print_block tail n' p in
head_str ^ rest, n''
and print_code (c:code) (n:int) (p:P.printer) : string & int =
match c with
| Ins ins -> (print_ins ins p ^ "\n", n)
| Block b -> print_block b n p
| IfElse cond true_code false_code ->
let n1 = n in
let n2 = n + 1 in
let cmp = print_cmp (P.cmp_not cond) n1 p in
let true_str, n' = print_code true_code (n + 2) p in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"L" ^ string_of_int n1 ^ ":\"\n" in
let false_str, n' = print_code false_code n' p in
let label2 = " \"L" ^ string_of_int n2 ^ ":\"\n" in
cmp ^ true_str ^ jmp ^ label1 ^ false_str ^ label2, n'
| While cond body ->
let n1 = n in
let n2 = n + 1 in
let jmp = " \" jmp L" ^ string_of_int n2 ^ ";\"\n" in
let label1 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n1 ^ ":\"\n" in
let body_str, n' = print_code body (n + 2) p in
let label2 = " \"" ^ p.P.align() ^ " 16\nL" ^ string_of_int n2 ^ ":\"\n" in
let cmp = print_cmp cond n1 p in
jmp ^ label1 ^ body_str ^ label2 ^ cmp, n'
let rec print_fn_comments = function
| [] -> ""
| hd::tl -> "// " ^ hd ^ "\n" ^ print_fn_comments tl
let rec remove_blank (c:code) : code =
match c with
| Ins _ -> c
| Block b -> Block (remove_blanks b)
| IfElse cond ct cf -> IfElse cond (remove_blank ct) (remove_blank cf)
| While cond cb -> While cond (remove_blank cb)
and remove_blanks (b:codes) : codes =
match b with
| [] -> []
| Ins (Instr _ _ (AnnotateGhost _)) :: cs -> remove_blanks cs
| Block b :: cs ->
(
match remove_blanks b with
| [] -> remove_blanks cs
| b -> Block b :: remove_blanks cs
)
| c :: cs -> c :: remove_blanks cs
// Check if any argument is passed in the rax register
let rec uses_rax (#n:nat) (args:list td) (i:nat{i + List.length args = n}) (of_arg:reg_nat n -> reg_64) =
match args with
| [] -> false
| a::q -> if of_arg i = rRax then true else uses_rax q (i+1) of_arg
let print_inline
(name:string)
(label:int)
(ret_val:option string)
(n:nat)
(args:list td{List.length args = n})
(arg_names:nat -> string)
(code:code)
(of_arg:reg_nat (List.length args) -> reg_64)
(regs_mod:reg_64 -> bool) | false | false | Vale.X64.Print_Inline_s.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val print_inline
(name: string)
(label: int)
(ret_val: option string)
(n: nat)
(args: list td {List.length args = n})
(arg_names: (nat -> string))
(code: code)
(of_arg: (reg_nat (List.length args) -> reg_64))
(regs_mod: (reg_64 -> bool))
(fn_comments: list string)
: FStar.All.ML int | [] | Vale.X64.Print_Inline_s.print_inline | {
"file_name": "vale/specs/hardware/Vale.X64.Print_Inline_s.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
name: Prims.string ->
label: Prims.int ->
ret_val: FStar.Pervasives.Native.option Prims.string ->
n: Prims.nat ->
args: Prims.list Vale.Interop.Base.td {FStar.List.Tot.Base.length args = n} ->
arg_names: (_: Prims.nat -> Prims.string) ->
code: Vale.X64.Machine_Semantics_s.code ->
of_arg:
(_: Vale.Interop.X64.reg_nat (FStar.List.Tot.Base.length args) -> Vale.X64.Machine_s.reg_64) ->
regs_mod: (_: Vale.X64.Machine_s.reg_64 -> Prims.bool) ->
fn_comments: Prims.list Prims.string
-> FStar.All.ML Prims.int | {
"end_col": 13,
"end_line": 407,
"start_col": 22,
"start_line": 339
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.Effect.Atomic",
"short_module": "AT"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let 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) = | false | null | false | x: US.t{US.v s <= US.v x /\ US.v x < US.v f} | {
"checked_file": "Steel.Loops.fsti.checked",
"dependencies": [
"Steel.Effect.Common.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Loops.fsti"
} | [
"total"
] | [
"FStar.SizeT.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.SizeT.v",
"Prims.op_LessThan"
] | [] | (*
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.Loops
open Steel.Effect.Common
open Steel.Effect
module AT = Steel.Effect.Atomic
module US = FStar.SizeT
(* This module provides some common iterative looping combinators *)
let nat_at_most (f:US.t)
= x:nat{ x <= US.v f } | false | true | Steel.Loops.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val u32_between : s: FStar.SizeT.t -> f: FStar.SizeT.t -> Type0 | [] | Steel.Loops.u32_between | {
"file_name": "lib/steel/Steel.Loops.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | s: FStar.SizeT.t -> f: FStar.SizeT.t -> Type0 | {
"end_col": 49,
"end_line": 28,
"start_col": 4,
"start_line": 28
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.Effect.Atomic",
"short_module": "AT"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let nat_at_most (f:US.t)
= x:nat{ x <= US.v f } | let nat_at_most (f: US.t) = | false | null | false | x: nat{x <= US.v f} | {
"checked_file": "Steel.Loops.fsti.checked",
"dependencies": [
"Steel.Effect.Common.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Loops.fsti"
} | [
"total"
] | [
"FStar.SizeT.t",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.SizeT.v"
] | [] | (*
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.Loops
open Steel.Effect.Common
open Steel.Effect
module AT = Steel.Effect.Atomic
module US = FStar.SizeT
(* This module provides some common iterative looping combinators *) | false | true | Steel.Loops.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val nat_at_most : f: FStar.SizeT.t -> Type0 | [] | Steel.Loops.nat_at_most | {
"file_name": "lib/steel/Steel.Loops.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f: FStar.SizeT.t -> Type0 | {
"end_col": 24,
"end_line": 25,
"start_col": 4,
"start_line": 25
} |
|
Steel.Effect.Steel | val for_loop_full
(start: US.t)
(finish: US.t{US.v start <= US.v finish})
(inv: (nat_at_most finish -> vprop))
(inv_sel: (i: nat_at_most finish -> t_of (inv i) -> prop))
(body:
(i: u32_between start finish
-> Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1))))))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish)))) | [
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.Effect.Atomic",
"short_module": "AT"
},
{
"abbrev": false,
"full_module": "Steel.Reference",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Memory",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.SizeT",
"short_module": "US"
},
{
"abbrev": true,
"full_module": "Steel.Effect.Atomic",
"short_module": "AT"
},
{
"abbrev": false,
"full_module": "Steel.Effect",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.Effect.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let for_loop_full
(start:US.t)
(finish:US.t { US.v start <= US.v finish })
(inv: nat_at_most finish -> vprop)
(inv_sel: (i:nat_at_most finish) -> t_of (inv i) -> prop)
(body:
(i:u32_between start finish ->
Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1)))
)))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish)))
)
= AT.intro_vrefine (inv (US.v start)) (inv_sel (US.v start));
for_loop start finish
(fun n -> inv n `vrefine` inv_sel n)
(fun i ->
AT.elim_vrefine (inv (US.v i)) (inv_sel (US.v i));
body i;
AT.intro_vrefine (inv (US.v i + 1)) (inv_sel (US.v i + 1))
);
AT.elim_vrefine (inv (US.v finish)) (inv_sel (US.v finish)) | val for_loop_full
(start: US.t)
(finish: US.t{US.v start <= US.v finish})
(inv: (nat_at_most finish -> vprop))
(inv_sel: (i: nat_at_most finish -> t_of (inv i) -> prop))
(body:
(i: u32_between start finish
-> Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1))))))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish))))
let for_loop_full
(start: US.t)
(finish: US.t{US.v start <= US.v finish})
(inv: (nat_at_most finish -> vprop))
(inv_sel: (i: nat_at_most finish -> t_of (inv i) -> prop))
(body:
(i: u32_between start finish
-> Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1))))))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish)))) = | true | null | false | AT.intro_vrefine (inv (US.v start)) (inv_sel (US.v start));
for_loop start
finish
(fun n -> (inv n) `vrefine` (inv_sel n))
(fun i ->
AT.elim_vrefine (inv (US.v i)) (inv_sel (US.v i));
body i;
AT.intro_vrefine (inv (US.v i + 1)) (inv_sel (US.v i + 1)));
AT.elim_vrefine (inv (US.v finish)) (inv_sel (US.v finish)) | {
"checked_file": "Steel.Loops.fsti.checked",
"dependencies": [
"Steel.Effect.Common.fsti.checked",
"Steel.Effect.Atomic.fsti.checked",
"Steel.Effect.fsti.checked",
"prims.fst.checked",
"FStar.SizeT.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.Loops.fsti"
} | [] | [
"FStar.SizeT.t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.SizeT.v",
"Steel.Loops.nat_at_most",
"Steel.Effect.Common.vprop",
"Steel.Effect.Common.t_of",
"Prims.prop",
"Steel.Loops.u32_between",
"Prims.unit",
"Prims.op_Addition",
"Steel.Effect.Common.rmem",
"Prims.l_and",
"Steel.Effect.Atomic.elim_vrefine",
"FStar.Ghost.hide",
"FStar.Set.set",
"Steel.Memory.iname",
"FStar.Set.empty",
"Steel.Loops.for_loop",
"Steel.Effect.Common.vrefine",
"Steel.Effect.Atomic.intro_vrefine"
] | [] | (*
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.Loops
open Steel.Effect.Common
open Steel.Effect
module AT = Steel.Effect.Atomic
module US = FStar.SizeT
(* This module provides some common iterative looping combinators *)
let nat_at_most (f:US.t)
= x:nat{ 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}
/// for_loop: for (i = start; i < finish; i++) inv { body i }
val for_loop (start:US.t)
(finish:US.t { US.v start <= US.v finish })
(inv: nat_at_most finish -> vprop)
(body:
(i:u32_between start finish ->
SteelT unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))))
: SteelT unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
inline_for_extraction
noextract
let for_loop_full
(start:US.t)
(finish:US.t { US.v start <= US.v finish })
(inv: nat_at_most finish -> vprop)
(inv_sel: (i:nat_at_most finish) -> t_of (inv i) -> prop)
(body:
(i:u32_between start finish ->
Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1)))
)))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish))) | false | false | Steel.Loops.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val for_loop_full
(start: US.t)
(finish: US.t{US.v start <= US.v finish})
(inv: (nat_at_most finish -> vprop))
(inv_sel: (i: nat_at_most finish -> t_of (inv i) -> prop))
(body:
(i: u32_between start finish
-> Steel unit
(inv (US.v i))
(fun _ -> inv (US.v i + 1))
(requires fun h -> inv_sel (US.v i) (h (inv (US.v i))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v i) (h0 (inv (US.v i))) /\
inv_sel (US.v i + 1) (h1 (inv (US.v i + 1))))))
: Steel unit
(inv (US.v start))
(fun _ -> inv (US.v finish))
(requires fun h -> inv_sel (US.v start) (h (inv (US.v start))))
(ensures
fun h0 _ h1 ->
inv_sel (US.v start) (h0 (inv (US.v start))) /\
inv_sel (US.v finish) (h1 (inv (US.v finish)))) | [] | Steel.Loops.for_loop_full | {
"file_name": "lib/steel/Steel.Loops.fsti",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} |
start: FStar.SizeT.t ->
finish: FStar.SizeT.t{FStar.SizeT.v start <= FStar.SizeT.v finish} ->
inv: (_: Steel.Loops.nat_at_most finish -> Steel.Effect.Common.vprop) ->
inv_sel:
(i: Steel.Loops.nat_at_most finish -> _: Steel.Effect.Common.t_of (inv i) -> Prims.prop) ->
body: (i: Steel.Loops.u32_between start finish -> Steel.Effect.Steel Prims.unit)
-> Steel.Effect.Steel Prims.unit | {
"end_col": 61,
"end_line": 76,
"start_col": 2,
"start_line": 68
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Poly1305_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let poly1305_padded_128 = Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded #M128 | let poly1305_padded_128 = | false | null | false | Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded #M128 | {
"checked_file": "Hacl.Chacha20Poly1305_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Poly1305_128.fsti.checked",
"Hacl.Meta.Chacha20Poly1305.fst.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Chacha20Poly1305.PolyCore.fst.checked",
"Hacl.Impl.Chacha20Poly1305.fst.checked",
"Hacl.Chacha20.Vec128.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Chacha20Poly1305_128.fst"
} | [
"total"
] | [
"Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded",
"Hacl.Impl.Poly1305.Fields.M128"
] | [] | module Hacl.Chacha20Poly1305_128
open Hacl.Meta.Chacha20Poly1305
open Hacl.Impl.Chacha20Poly1305
open Hacl.Impl.Poly1305.Fields
open Hacl.Poly1305_128
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
[@CInline] | false | true | Hacl.Chacha20Poly1305_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val poly1305_padded_128 : Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded_st Hacl.Impl.Poly1305.Fields.M128 | [] | Hacl.Chacha20Poly1305_128.poly1305_padded_128 | {
"file_name": "code/chacha20poly1305/Hacl.Chacha20Poly1305_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded_st Hacl.Impl.Poly1305.Fields.M128 | {
"end_col": 83,
"end_line": 13,
"start_col": 26,
"start_line": 13
} |
|
Prims.Tot | val aead_decrypt:aead_decrypt_st M128 | [
{
"abbrev": false,
"full_module": "Hacl.Poly1305_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aead_decrypt : aead_decrypt_st M128 =
chacha20poly1305_aead_decrypt_higher #M128 True Hacl.Chacha20.Vec128.chacha20_encrypt_128 poly1305_do_128 | val aead_decrypt:aead_decrypt_st M128
let aead_decrypt:aead_decrypt_st M128 = | false | null | false | chacha20poly1305_aead_decrypt_higher #M128
True
Hacl.Chacha20.Vec128.chacha20_encrypt_128
poly1305_do_128 | {
"checked_file": "Hacl.Chacha20Poly1305_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Poly1305_128.fsti.checked",
"Hacl.Meta.Chacha20Poly1305.fst.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Chacha20Poly1305.PolyCore.fst.checked",
"Hacl.Impl.Chacha20Poly1305.fst.checked",
"Hacl.Chacha20.Vec128.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Chacha20Poly1305_128.fst"
} | [
"total"
] | [
"Hacl.Meta.Chacha20Poly1305.chacha20poly1305_aead_decrypt_higher",
"Hacl.Impl.Poly1305.Fields.M128",
"Prims.l_True",
"Hacl.Chacha20.Vec128.chacha20_encrypt_128",
"Hacl.Chacha20Poly1305_128.poly1305_do_128"
] | [] | module Hacl.Chacha20Poly1305_128
open Hacl.Meta.Chacha20Poly1305
open Hacl.Impl.Chacha20Poly1305
open Hacl.Impl.Poly1305.Fields
open Hacl.Poly1305_128
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
[@CInline]
private
let poly1305_padded_128 = Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded #M128
[@CInline]
private
let poly1305_do_128 = chacha20poly1305_poly1305_do_higher #M128 True poly1305_finish poly1305_init poly1305_padded_128
[@@ Comment "Encrypt a message `m` with key `k`.
The arguments `k`, `n`, `aadlen`, and `aad` are same in encryption/decryption.
Note: Encryption and decryption can be executed in-place, i.e., `m` and `cipher` can point to the same memory.
@param k Pointer to 32 bytes of memory where the AEAD key is read from.
@param n Pointer to 12 bytes of memory where the AEAD nonce is read from.
@param aadlen Length of the associated data.
@param aad Pointer to `aadlen` bytes of memory where the associated data is read from.
@param mlen Length of the message.
@param m Pointer to `mlen` bytes of memory where the message is read from.
@param cipher Pointer to `mlen` bytes of memory where the ciphertext is written to.
@param mac Pointer to 16 bytes of memory where the mac is written to."]
let aead_encrypt : aead_encrypt_st M128 =
chacha20poly1305_aead_encrypt_higher #M128 True poly1305_do_128 Hacl.Chacha20.Vec128.chacha20_encrypt_128
[@@ Comment "Decrypt a ciphertext `cipher` with key `k`.
The arguments `k`, `n`, `aadlen`, and `aad` are same in encryption/decryption.
Note: Encryption and decryption can be executed in-place, i.e., `m` and `cipher` can point to the same memory.
If decryption succeeds, the resulting plaintext is stored in `m` and the function returns the success code 0.
If decryption fails, the array `m` remains unchanged and the function returns the error code 1.
@param k Pointer to 32 bytes of memory where the AEAD key is read from.
@param n Pointer to 12 bytes of memory where the AEAD nonce is read from.
@param aadlen Length of the associated data.
@param aad Pointer to `aadlen` bytes of memory where the associated data is read from.
@param mlen Length of the ciphertext.
@param m Pointer to `mlen` bytes of memory where the message is written to.
@param cipher Pointer to `mlen` bytes of memory where the ciphertext is read from.
@param mac Pointer to 16 bytes of memory where the mac is read from.
@returns 0 on succeess; 1 on failure."] | false | false | Hacl.Chacha20Poly1305_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aead_decrypt:aead_decrypt_st M128 | [] | Hacl.Chacha20Poly1305_128.aead_decrypt | {
"file_name": "code/chacha20poly1305/Hacl.Chacha20Poly1305_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Chacha20Poly1305.aead_decrypt_st Hacl.Impl.Poly1305.Fields.M128 | {
"end_col": 107,
"end_line": 55,
"start_col": 2,
"start_line": 55
} |
Prims.Tot | val aead_encrypt:aead_encrypt_st M128 | [
{
"abbrev": false,
"full_module": "Hacl.Poly1305_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let aead_encrypt : aead_encrypt_st M128 =
chacha20poly1305_aead_encrypt_higher #M128 True poly1305_do_128 Hacl.Chacha20.Vec128.chacha20_encrypt_128 | val aead_encrypt:aead_encrypt_st M128
let aead_encrypt:aead_encrypt_st M128 = | false | null | false | chacha20poly1305_aead_encrypt_higher #M128
True
poly1305_do_128
Hacl.Chacha20.Vec128.chacha20_encrypt_128 | {
"checked_file": "Hacl.Chacha20Poly1305_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Poly1305_128.fsti.checked",
"Hacl.Meta.Chacha20Poly1305.fst.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Chacha20Poly1305.PolyCore.fst.checked",
"Hacl.Impl.Chacha20Poly1305.fst.checked",
"Hacl.Chacha20.Vec128.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Chacha20Poly1305_128.fst"
} | [
"total"
] | [
"Hacl.Meta.Chacha20Poly1305.chacha20poly1305_aead_encrypt_higher",
"Hacl.Impl.Poly1305.Fields.M128",
"Prims.l_True",
"Hacl.Chacha20Poly1305_128.poly1305_do_128",
"Hacl.Chacha20.Vec128.chacha20_encrypt_128"
] | [] | module Hacl.Chacha20Poly1305_128
open Hacl.Meta.Chacha20Poly1305
open Hacl.Impl.Chacha20Poly1305
open Hacl.Impl.Poly1305.Fields
open Hacl.Poly1305_128
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
[@CInline]
private
let poly1305_padded_128 = Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded #M128
[@CInline]
private
let poly1305_do_128 = chacha20poly1305_poly1305_do_higher #M128 True poly1305_finish poly1305_init poly1305_padded_128
[@@ Comment "Encrypt a message `m` with key `k`.
The arguments `k`, `n`, `aadlen`, and `aad` are same in encryption/decryption.
Note: Encryption and decryption can be executed in-place, i.e., `m` and `cipher` can point to the same memory.
@param k Pointer to 32 bytes of memory where the AEAD key is read from.
@param n Pointer to 12 bytes of memory where the AEAD nonce is read from.
@param aadlen Length of the associated data.
@param aad Pointer to `aadlen` bytes of memory where the associated data is read from.
@param mlen Length of the message.
@param m Pointer to `mlen` bytes of memory where the message is read from.
@param cipher Pointer to `mlen` bytes of memory where the ciphertext is written to.
@param mac Pointer to 16 bytes of memory where the mac is written to."] | false | false | Hacl.Chacha20Poly1305_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val aead_encrypt:aead_encrypt_st M128 | [] | Hacl.Chacha20Poly1305_128.aead_encrypt | {
"file_name": "code/chacha20poly1305/Hacl.Chacha20Poly1305_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Chacha20Poly1305.aead_encrypt_st Hacl.Impl.Poly1305.Fields.M128 | {
"end_col": 107,
"end_line": 33,
"start_col": 2,
"start_line": 33
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Hacl.Poly1305_128",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Poly1305.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Chacha20Poly1305",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let poly1305_do_128 = chacha20poly1305_poly1305_do_higher #M128 True poly1305_finish poly1305_init poly1305_padded_128 | let poly1305_do_128 = | false | null | false | chacha20poly1305_poly1305_do_higher #M128 True poly1305_finish poly1305_init poly1305_padded_128 | {
"checked_file": "Hacl.Chacha20Poly1305_128.fst.checked",
"dependencies": [
"prims.fst.checked",
"Hacl.Poly1305_128.fsti.checked",
"Hacl.Meta.Chacha20Poly1305.fst.checked",
"Hacl.Impl.Poly1305.Fields.fst.checked",
"Hacl.Impl.Chacha20Poly1305.PolyCore.fst.checked",
"Hacl.Impl.Chacha20Poly1305.fst.checked",
"Hacl.Chacha20.Vec128.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Chacha20Poly1305_128.fst"
} | [
"total"
] | [
"Hacl.Meta.Chacha20Poly1305.chacha20poly1305_poly1305_do_higher",
"Hacl.Impl.Poly1305.Fields.M128",
"Prims.l_True",
"Hacl.Poly1305_128.poly1305_finish",
"Hacl.Poly1305_128.poly1305_init",
"Hacl.Chacha20Poly1305_128.poly1305_padded_128"
] | [] | module Hacl.Chacha20Poly1305_128
open Hacl.Meta.Chacha20Poly1305
open Hacl.Impl.Chacha20Poly1305
open Hacl.Impl.Poly1305.Fields
open Hacl.Poly1305_128
#set-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
[@CInline]
private
let poly1305_padded_128 = Hacl.Impl.Chacha20Poly1305.PolyCore.poly1305_padded #M128
[@CInline] | false | true | Hacl.Chacha20Poly1305_128.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val poly1305_do_128 : Hacl.Meta.Chacha20Poly1305.chacha20poly1305_poly1305_do_higher_t Prims.l_True | [] | Hacl.Chacha20Poly1305_128.poly1305_do_128 | {
"file_name": "code/chacha20poly1305/Hacl.Chacha20Poly1305_128.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Chacha20Poly1305.chacha20poly1305_poly1305_do_higher_t Prims.l_True | {
"end_col": 118,
"end_line": 16,
"start_col": 22,
"start_line": 16
} |
|
Prims.Tot | val le_to_n_indexed (b: FE.bytes) : nat | [
{
"abbrev": true,
"full_module": "Lib.RawIntTypes",
"short_module": "Raw"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Vale.Wrapper.X64.Poly",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Types",
"short_module": "IT"
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Util",
"short_module": "PU"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Endianness",
"short_module": "FE"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Lib.IntTypes",
"short_module": "LI"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let le_to_n_indexed (b:FE.bytes) : nat =
le_to_n_indexed_rec b (length b) | val le_to_n_indexed (b: FE.bytes) : nat
let le_to_n_indexed (b: FE.bytes) : nat = | false | null | false | le_to_n_indexed_rec b (length b) | {
"checked_file": "Vale.Arch.BufferFriend.fsti.checked",
"dependencies": [
"Vale.Interop.Views.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Up.fsti.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Endianness.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Arch.BufferFriend.fsti"
} | [
"total"
] | [
"FStar.Endianness.bytes",
"Vale.Arch.BufferFriend.le_to_n_indexed_rec",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.nat"
] | [] | module Vale.Arch.BufferFriend
module B = LowStar.Buffer
module LI = Lib.IntTypes
module BS = Lib.ByteSequence
module FE = FStar.Endianness
module HS = FStar.HyperStack
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Seq.Base
val to_bytes (s:seq UInt8.t) : Tot (b:BS.bytes{b === s /\ length b == length s})
val of_bytes (b:BS.bytes) : Tot (s:seq UInt8.t{b === s /\ length b == length s})
val lemma_to_bytes_slice (s:seq UInt8.t) (i j:nat) : Lemma
(requires i <= j /\ j <= length s)
(ensures to_bytes (slice s i j) == slice (to_bytes s) i j)
[SMTPat (to_bytes (slice s i j))]
val lemma_of_bytes_slice (b:BS.bytes) (i j:nat) : Lemma
(requires i <= j /\ j <= length b)
(ensures of_bytes (slice b i j) == slice (of_bytes b) i j)
[SMTPat (of_bytes (slice b i j))]
val lemma_up_as_seq_index (#b:_) (h:HS.mem) (vb:UV.buffer b) (i:nat) : Lemma
(requires i < length (UV.as_seq h vb) /\ UV.View?.n (UV.get_view vb) == 8) // TODO: generalize this beyond n = 8
(ensures (
let s0 = DV.as_seq h (UV.as_down_buffer vb) in
let v = UV.get_view vb in
let n = UV.View?.n v in
let start = i * n in
0 <= start /\ start + n <= length s0 /\
index (UV.as_seq h vb) i == UV.View?.get v (slice s0 start (start + n))
))
// TODO: this was copied out of Vale.SHA.Simplify_Sha.fst, but with the liveness requirement on b removed; we could consolidate the two versions
val same_seq_downview8 (b:B.buffer UInt8.t) (h:HS.mem) : Lemma
(DV.as_seq h (DV.mk_buffer_view b (Vale.Interop.Views.down_view8)) == B.as_seq h b)
val lemma_le_to_n_is_nat_from_bytes (s:FE.bytes) : Lemma
(ensures FE.le_to_n s == BS.nat_from_bytes_le (to_bytes s))
(decreases (length s))
val lemma_n_to_le_is_nat_to_bytes (len:nat) (n:nat) : Lemma
(requires n < pow2 (8 * len))
(ensures FE.n_to_le len n == of_bytes (BS.nat_to_bytes_le len n))
(decreases len)
val lemma_be_to_n_is_nat_from_bytes (s:FE.bytes) : Lemma
(ensures FE.be_to_n s == BS.nat_from_bytes_be (to_bytes s))
(decreases (length s))
val lemma_n_to_be_is_nat_to_bytes (len:nat) (n:nat) : Lemma
(requires n < pow2 (8 * len))
(ensures FE.n_to_be len n == of_bytes (BS.nat_to_bytes_be len n))
(decreases len)
val nat_from_bytes_le_is_four_to_nat (b:BS.bytes) : Lemma
(requires length b == 4)
(ensures
BS.nat_from_bytes_le b ==
Vale.Def.Words.Four_s.four_to_nat 8 (Vale.Def.Words.Four_s.four_map LI.uint_v (Vale.Def.Words.Seq_s.seq_to_four_LE b))
)
val nat_from_bytes_le_is_le_bytes_to_nat32 (b:BS.bytes) : Lemma
(requires length b == 4)
(ensures
length (of_bytes b) == 4 /\
BS.nat_from_bytes_le b == le_bytes_to_nat32 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (of_bytes b))
)
val nat_from_bytes_le_is_le_bytes_to_nat64 (b:BS.bytes) : Lemma
(requires length b == 8)
(ensures
length (of_bytes b) == 8 /\
BS.nat_from_bytes_le b == le_bytes_to_nat64 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (of_bytes b))
)
// useful with norm_spec [iota; zeta; primops; delta_only [`%le_to_n_indexed_rec; `%pow2]]
let rec le_to_n_indexed_rec (b:FE.bytes) (i:nat{i <= length b}) : nat =
if i = 0 then 0
else UInt8.v (index b (length b - i)) + pow2 8 * le_to_n_indexed_rec b (i - 1) | false | true | Vale.Arch.BufferFriend.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val le_to_n_indexed (b: FE.bytes) : nat | [] | Vale.Arch.BufferFriend.le_to_n_indexed | {
"file_name": "vale/code/arch/Vale.Arch.BufferFriend.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: FStar.Endianness.bytes -> Prims.nat | {
"end_col": 34,
"end_line": 89,
"start_col": 2,
"start_line": 89
} |
Prims.Tot | val le_to_n_indexed_rec (b: FE.bytes) (i: nat{i <= length b}) : nat | [
{
"abbrev": true,
"full_module": "Lib.RawIntTypes",
"short_module": "Raw"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Vale.Wrapper.X64.Poly",
"short_module": "PS"
},
{
"abbrev": true,
"full_module": "Vale.Interop.Types",
"short_module": "IT"
},
{
"abbrev": true,
"full_module": "Vale.Poly1305.Util",
"short_module": "PU"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.Endianness",
"short_module": "FE"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BS"
},
{
"abbrev": true,
"full_module": "Lib.IntTypes",
"short_module": "LI"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec le_to_n_indexed_rec (b:FE.bytes) (i:nat{i <= length b}) : nat =
if i = 0 then 0
else UInt8.v (index b (length b - i)) + pow2 8 * le_to_n_indexed_rec b (i - 1) | val le_to_n_indexed_rec (b: FE.bytes) (i: nat{i <= length b}) : nat
let rec le_to_n_indexed_rec (b: FE.bytes) (i: nat{i <= length b}) : nat = | false | null | false | if i = 0 then 0 else UInt8.v (index b (length b - i)) + pow2 8 * le_to_n_indexed_rec b (i - 1) | {
"checked_file": "Vale.Arch.BufferFriend.fsti.checked",
"dependencies": [
"Vale.Interop.Views.fsti.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Words.Four_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Up.fsti.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.fst.checked",
"FStar.Endianness.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Arch.BufferFriend.fsti"
} | [
"total"
] | [
"FStar.Endianness.bytes",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.UInt8.t",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Prims.op_Addition",
"FStar.UInt8.v",
"FStar.Seq.Base.index",
"Prims.op_Subtraction",
"FStar.Mul.op_Star",
"Prims.pow2",
"Vale.Arch.BufferFriend.le_to_n_indexed_rec"
] | [] | module Vale.Arch.BufferFriend
module B = LowStar.Buffer
module LI = Lib.IntTypes
module BS = Lib.ByteSequence
module FE = FStar.Endianness
module HS = FStar.HyperStack
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.Def.Words_s
open Vale.Def.Types_s
open FStar.Mul
open FStar.Seq.Base
val to_bytes (s:seq UInt8.t) : Tot (b:BS.bytes{b === s /\ length b == length s})
val of_bytes (b:BS.bytes) : Tot (s:seq UInt8.t{b === s /\ length b == length s})
val lemma_to_bytes_slice (s:seq UInt8.t) (i j:nat) : Lemma
(requires i <= j /\ j <= length s)
(ensures to_bytes (slice s i j) == slice (to_bytes s) i j)
[SMTPat (to_bytes (slice s i j))]
val lemma_of_bytes_slice (b:BS.bytes) (i j:nat) : Lemma
(requires i <= j /\ j <= length b)
(ensures of_bytes (slice b i j) == slice (of_bytes b) i j)
[SMTPat (of_bytes (slice b i j))]
val lemma_up_as_seq_index (#b:_) (h:HS.mem) (vb:UV.buffer b) (i:nat) : Lemma
(requires i < length (UV.as_seq h vb) /\ UV.View?.n (UV.get_view vb) == 8) // TODO: generalize this beyond n = 8
(ensures (
let s0 = DV.as_seq h (UV.as_down_buffer vb) in
let v = UV.get_view vb in
let n = UV.View?.n v in
let start = i * n in
0 <= start /\ start + n <= length s0 /\
index (UV.as_seq h vb) i == UV.View?.get v (slice s0 start (start + n))
))
// TODO: this was copied out of Vale.SHA.Simplify_Sha.fst, but with the liveness requirement on b removed; we could consolidate the two versions
val same_seq_downview8 (b:B.buffer UInt8.t) (h:HS.mem) : Lemma
(DV.as_seq h (DV.mk_buffer_view b (Vale.Interop.Views.down_view8)) == B.as_seq h b)
val lemma_le_to_n_is_nat_from_bytes (s:FE.bytes) : Lemma
(ensures FE.le_to_n s == BS.nat_from_bytes_le (to_bytes s))
(decreases (length s))
val lemma_n_to_le_is_nat_to_bytes (len:nat) (n:nat) : Lemma
(requires n < pow2 (8 * len))
(ensures FE.n_to_le len n == of_bytes (BS.nat_to_bytes_le len n))
(decreases len)
val lemma_be_to_n_is_nat_from_bytes (s:FE.bytes) : Lemma
(ensures FE.be_to_n s == BS.nat_from_bytes_be (to_bytes s))
(decreases (length s))
val lemma_n_to_be_is_nat_to_bytes (len:nat) (n:nat) : Lemma
(requires n < pow2 (8 * len))
(ensures FE.n_to_be len n == of_bytes (BS.nat_to_bytes_be len n))
(decreases len)
val nat_from_bytes_le_is_four_to_nat (b:BS.bytes) : Lemma
(requires length b == 4)
(ensures
BS.nat_from_bytes_le b ==
Vale.Def.Words.Four_s.four_to_nat 8 (Vale.Def.Words.Four_s.four_map LI.uint_v (Vale.Def.Words.Seq_s.seq_to_four_LE b))
)
val nat_from_bytes_le_is_le_bytes_to_nat32 (b:BS.bytes) : Lemma
(requires length b == 4)
(ensures
length (of_bytes b) == 4 /\
BS.nat_from_bytes_le b == le_bytes_to_nat32 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (of_bytes b))
)
val nat_from_bytes_le_is_le_bytes_to_nat64 (b:BS.bytes) : Lemma
(requires length b == 8)
(ensures
length (of_bytes b) == 8 /\
BS.nat_from_bytes_le b == le_bytes_to_nat64 (Vale.Def.Words.Seq_s.seq_uint8_to_seq_nat8 (of_bytes b))
)
// useful with norm_spec [iota; zeta; primops; delta_only [`%le_to_n_indexed_rec; `%pow2]] | false | false | Vale.Arch.BufferFriend.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val le_to_n_indexed_rec (b: FE.bytes) (i: nat{i <= length b}) : nat | [
"recursion"
] | Vale.Arch.BufferFriend.le_to_n_indexed_rec | {
"file_name": "vale/code/arch/Vale.Arch.BufferFriend.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: FStar.Endianness.bytes -> i: Prims.nat{i <= FStar.Seq.Base.length b} -> Prims.nat | {
"end_col": 80,
"end_line": 86,
"start_col": 2,
"start_line": 85
} |
Prims.Tot | val poly_equal (a b: poly) : prop0 | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i]) | val poly_equal (a b: poly) : prop0
let poly_equal (a b: poly) : prop0 = | false | null | false | (forall (i: nat). {:pattern a.[ i ]\/b.[ i ]} a.[ i ] == b.[ i ]) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"total"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.l_Forall",
"Prims.nat",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10" | false | true | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val poly_equal (a b: poly) : prop0 | [] | Vale.Math.Poly2.Defs.poly_equal | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> Vale.Def.Prop_s.prop0 | {
"end_col": 59,
"end_line": 11,
"start_col": 2,
"start_line": 11
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let max = FStar.Math.Lib.max | let max = | false | null | false | FStar.Math.Lib.max | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"total"
] | [
"FStar.Math.Lib.max"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val max : x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = x) /\ (x < y ==> z = y)} | [] | Vale.Math.Poly2.Defs.max | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Prims.int -> y: Prims.int -> z: Prims.int{(x >= y ==> z = x) /\ (x < y ==> z = y)} | {
"end_col": 35,
"end_line": 6,
"start_col": 17,
"start_line": 6
} |
|
FStar.Pervasives.Lemma | val lemma_poly_equal_elim (a b: poly)
: Lemma (requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)] | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b) | val lemma_poly_equal_elim (a b: poly)
: Lemma (requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
let lemma_poly_equal_elim (a b: poly)
: Lemma (requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)] = | false | null | true | let len = max (length a) (length b) in
assert (len > 0 ==> a.[ len - 1 ] == b.[ len - 1 ]);
assert (length a == length b);
assert (forall (i: nat). {:pattern (index a i)\/(index b i)} a.[ i ] == b.[ i ]);
assert (equal a b) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims._assert",
"FStar.Seq.Base.equal",
"Prims.bool",
"Prims.unit",
"Prims.l_Forall",
"Prims.nat",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"FStar.Seq.Base.index",
"FStar.Seq.Base.length",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_Subtraction",
"Prims.int",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Equality",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.max",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Prims.squash",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Vale.Def.Prop_s.prop0",
"Vale.Math.Poly2.Defs.poly_equal",
"Prims.Nil"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_poly_equal_elim (a b: poly)
: Lemma (requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)] | [] | Vale.Math.Poly2.Defs.lemma_poly_equal_elim | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (requires a =. b)
(ensures a == b)
(decreases FStar.Seq.Base.length a + FStar.Seq.Base.length b)
[SMTPat (Vale.Math.Poly2.Defs.poly_equal a b)] | {
"end_col": 20,
"end_line": 29,
"start_col": 3,
"start_line": 24
} |
FStar.Pervasives.Lemma | val lemma_sum_reverse (j k: int) (f g: (int -> bool))
: Lemma
(requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f' | val lemma_sum_reverse (j k: int) (f g: (int -> bool))
: Lemma
(requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
let lemma_sum_reverse (j k: int) (f g: (int -> bool))
: Lemma
(requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g) = | false | null | true | let f' (i: int) = f (- i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f' | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Prims.int",
"Prims.bool",
"Vale.Math.Poly2.Defs.lemma_sum_shift",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_sum_invert",
"Prims.op_Minus",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_LessThan",
"Prims.eq2",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1))) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_reverse (j k: int) (f g: (int -> bool))
: Lemma
(requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g) | [] | Vale.Math.Poly2.Defs.lemma_sum_reverse | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | j: Prims.int -> k: Prims.int -> f: (_: Prims.int -> Prims.bool) -> g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == g (k + j - i - 1))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f == Vale.Math.Poly2.Defs_s.sum_of_bools j k g) | {
"end_col": 40,
"end_line": 123,
"start_col": 3,
"start_line": 120
} |
FStar.Pervasives.Lemma | val lemma_sum_of_pairs (j k: int) (f g h: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h | val lemma_sum_of_pairs (j k: int) (f g h: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
let rec lemma_sum_of_pairs (j k: int) (f g h: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j)) = | false | null | true | if j < k then lemma_sum_of_pairs j (k - 1) f g h | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_of_pairs",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Prims.op_disEquality",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_of_pairs (j k: int) (f g h: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_of_pairs | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
k: Prims.int ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool) ->
h: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == (g i <> h i))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
(Vale.Math.Poly2.Defs_s.sum_of_bools j k g <> Vale.Math.Poly2.Defs_s.sum_of_bools j k h))
(decreases k - j) | {
"end_col": 50,
"end_line": 91,
"start_col": 2,
"start_line": 91
} |
FStar.Pervasives.Lemma | val lemma_pointwise_equal (a b: poly) (pf: (i: int -> Lemma (a.[ i ] == b.[ i ]))) : Lemma (a == b) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b | val lemma_pointwise_equal (a b: poly) (pf: (i: int -> Lemma (a.[ i ] == b.[ i ]))) : Lemma (a == b)
let lemma_pointwise_equal (a b: poly) (pf: (i: int -> Lemma (a.[ i ] == b.[ i ]))) : Lemma (a == b) = | false | null | true | FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.int",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_poly_equal_elim",
"FStar.Classical.forall_intro"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_pointwise_equal (a b: poly) (pf: (i: int -> Lemma (a.[ i ] == b.[ i ]))) : Lemma (a == b) | [] | Vale.Math.Poly2.Defs.lemma_pointwise_equal | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Vale.Math.Poly2.Defs_s.poly ->
b: Vale.Math.Poly2.Defs_s.poly ->
pf: (i: Prims.int -> FStar.Pervasives.Lemma (ensures a.[ i ] == b.[ i ]))
-> FStar.Pervasives.Lemma (ensures a == b) | {
"end_col": 27,
"end_line": 33,
"start_col": 2,
"start_line": 32
} |
FStar.Pervasives.Lemma | val lemma_sum_extend (j' j k k': int) (f: (int -> bool))
: Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i: int). {:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i: int). {:pattern (f i)} k <= i /\ i < k' ==> not (f i)))
(ensures sum_of_bools j' k' f == sum_of_bools j k f) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f | val lemma_sum_extend (j' j k k': int) (f: (int -> bool))
: Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i: int). {:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i: int). {:pattern (f i)} k <= i /\ i < k' ==> not (f i)))
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
let lemma_sum_extend (j' j k k': int) (f: (int -> bool))
: Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i: int). {:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i: int). {:pattern (f i)} k <= i /\ i < k' ==> not (f i)))
(ensures sum_of_bools j' k' f == sum_of_bools j k f) = | false | null | true | lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Prims.int",
"Prims.bool",
"Vale.Math.Poly2.Defs.lemma_sum_join",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_Negation",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_extend (j' j k k': int) (f: (int -> bool))
: Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i: int). {:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i: int). {:pattern (f i)} k <= i /\ i < k' ==> not (f i)))
(ensures sum_of_bools j' k' f == sum_of_bools j k f) | [] | Vale.Math.Poly2.Defs.lemma_sum_extend | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | j': Prims.int -> j: Prims.int -> k: Prims.int -> k': Prims.int -> f: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i: Prims.int). {:pattern f i} j' <= i /\ i < j ==> Prims.op_Negation (f i)) /\
(forall (i: Prims.int). {:pattern f i} k <= i /\ i < k' ==> Prims.op_Negation (f i)))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j' k' f == Vale.Math.Poly2.Defs_s.sum_of_bools j k f) | {
"end_col": 26,
"end_line": 84,
"start_col": 2,
"start_line": 81
} |
FStar.Pervasives.Lemma | val lemma_sum_pointwise_equal (j k: int) (f g: (int -> bool)) (pf: (i: int -> Lemma (f i == g i)))
: Lemma (ensures sum_of_bools j k f == sum_of_bools j k g) (decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
) | val lemma_sum_pointwise_equal (j k: int) (f g: (int -> bool)) (pf: (i: int -> Lemma (f i == g i)))
: Lemma (ensures sum_of_bools j k f == sum_of_bools j k g) (decreases (k - j))
let rec lemma_sum_pointwise_equal
(j k: int)
(f g: (int -> bool))
(pf: (i: int -> Lemma (f i == g i)))
: Lemma (ensures sum_of_bools j k f == sum_of_bools j k g) (decreases (k - j)) = | false | null | true | if j < k
then
(pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_pointwise_equal",
"Prims.op_Subtraction",
"Vale.Math.Poly2.Defs_s.sum_of_bools"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_pointwise_equal (j k: int) (f g: (int -> bool)) (pf: (i: int -> Lemma (f i == g i)))
: Lemma (ensures sum_of_bools j k f == sum_of_bools j k g) (decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_pointwise_equal | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
k: Prims.int ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool) ->
pf: (i: Prims.int -> FStar.Pervasives.Lemma (ensures f i == g i))
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f == Vale.Math.Poly2.Defs_s.sum_of_bools j k g)
(decreases k - j) | {
"end_col": 3,
"end_line": 218,
"start_col": 2,
"start_line": 214
} |
FStar.Pervasives.Lemma | val lemma_mul_commute (a b: poly) : Lemma ((a *. b) =. (b *. a)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f | val lemma_mul_commute (a b: poly) : Lemma ((a *. b) =. (b *. a))
let lemma_mul_commute (a b: poly) : Lemma ((a *. b) =. (b *. a)) = | false | null | true | let f (k: nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.mul_element",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_reverse",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_commute (a b: poly) : Lemma ((a *. b) =. (b *. a)) | [] | Vale.Math.Poly2.Defs.lemma_mul_commute | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures a *. b =. b *. a) | {
"end_col": 32,
"end_line": 246,
"start_col": 65,
"start_line": 242
} |
FStar.Pervasives.Lemma | val lemma_sum_of_zero (j k: int) (f: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f | val lemma_sum_of_zero (j k: int) (f: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
let rec lemma_sum_of_zero (j k: int) (f: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j)) = | false | null | true | if j < k then lemma_sum_of_zero j (k - 1) f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Negation",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_of_zero (j k: int) (f: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_of_zero | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | j: Prims.int -> k: Prims.int -> f: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> Prims.op_Negation (f i))
(ensures Prims.op_Negation (Vale.Math.Poly2.Defs_s.sum_of_bools j k f))
(decreases k - j) | {
"end_col": 45,
"end_line": 64,
"start_col": 2,
"start_line": 64
} |
FStar.Pervasives.Lemma | val lemma_sum_join (i j k: int) (f: (int -> bool))
: Lemma (requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f | val lemma_sum_join (i j k: int) (f: (int -> bool))
: Lemma (requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
let rec lemma_sum_join (i j k: int) (f: (int -> bool))
: Lemma (requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j)) = | false | null | true | if j < k then lemma_sum_join i j (k - 1) f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_join",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.op_disEquality",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_join (i j k: int) (f: (int -> bool))
: Lemma (requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_join | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Prims.int -> j: Prims.int -> k: Prims.int -> f: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma (requires i <= j /\ j <= k)
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools i k f ==
(Vale.Math.Poly2.Defs_s.sum_of_bools i j f <> Vale.Math.Poly2.Defs_s.sum_of_bools j k f))
(decreases k - j) | {
"end_col": 44,
"end_line": 71,
"start_col": 2,
"start_line": 71
} |
FStar.Pervasives.Lemma | val lemma_mul_distribute_left (a b c: poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b | val lemma_mul_distribute_left (a b c: poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c))
let lemma_mul_distribute_left (a b c: poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) = | false | null | true | lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Vale.Math.Poly2.Defs.lemma_mul_distribute",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_mul_commute",
"Vale.Math.Poly2.Defs.op_Plus_Dot",
"Prims.l_True",
"Prims.squash",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_distribute_left (a b c: poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) | [] | Vale.Math.Poly2.Defs.lemma_mul_distribute_left | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> c: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures (a +. b) *. c =. a *. c +. b *. c) | {
"end_col": 28,
"end_line": 297,
"start_col": 2,
"start_line": 294
} |
FStar.Pervasives.Lemma | val lemma_sum_invert (j k: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g | val lemma_sum_invert (j k: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
let lemma_sum_invert (j k: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g) = | false | null | true | if j < k then lemma_sum_invert_rec j k k f g | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_invert_rec",
"Prims.unit",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Prims.op_Minus",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.op_Subtraction",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_invert (j k: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g) | [] | Vale.Math.Poly2.Defs.lemma_sum_invert | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | j: Prims.int -> k: Prims.int -> f: (_: Prims.int -> Prims.bool) -> g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == g (- i))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
Vale.Math.Poly2.Defs_s.sum_of_bools (1 - k) (1 - j) g) | {
"end_col": 46,
"end_line": 115,
"start_col": 2,
"start_line": 115
} |
FStar.Pervasives.Lemma | val lemma_sum_shift (j k shift: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g | val lemma_sum_shift (j k shift: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
let rec lemma_sum_shift (j k shift: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j)) = | false | null | true | if j < k then lemma_sum_shift j (k - 1) shift f g | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_shift",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Prims.op_Addition",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_shift (j k shift: int) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_shift | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
k: Prims.int ->
shift: Prims.int ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == g (i + shift))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
Vale.Math.Poly2.Defs_s.sum_of_bools (j + shift) (k + shift) g)
(decreases k - j) | {
"end_col": 51,
"end_line": 98,
"start_col": 2,
"start_line": 98
} |
FStar.Pervasives.Lemma | val lemma_sum_mul (j k: int) (b: bool) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g | val lemma_sum_mul (j k: int) (b: bool) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
let rec lemma_sum_mul (j k: int) (b: bool) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j)) = | false | null | true | if j < k then lemma_sum_mul j (k - 1) b f g | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_mul",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Prims.op_AmpAmp",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_mul (j k: int) (b: bool) (f g: (int -> bool))
: Lemma (requires (forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_mul | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
k: Prims.int ->
b: Prims.bool ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == (b && g i))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
(b && Vale.Math.Poly2.Defs_s.sum_of_bools j k g))
(decreases k - j) | {
"end_col": 45,
"end_line": 130,
"start_col": 2,
"start_line": 130
} |
FStar.Pervasives.Lemma | val lemma_sum_invert_rec (j m k: int) (f g: (int -> bool))
: Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g | val lemma_sum_invert_rec (j m k: int) (f g: (int -> bool))
: Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
let rec lemma_sum_invert_rec (j m k: int) (f g: (int -> bool))
: Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j)) = | false | null | true | if j < m then lemma_sum_invert_rec j (m - 1) k f g | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_invert_rec",
"Prims.op_Subtraction",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.op_disEquality",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_Minus",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_invert_rec (j m k: int) (f g: (int -> bool))
: Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i: int). {:pattern (f i)} j <= i /\ i < k ==> f i == g (- i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_invert_rec | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
m: Prims.int ->
k: Prims.int ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires
j <= m /\ m <= k /\
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
(Vale.Math.Poly2.Defs_s.sum_of_bools j m f <>
Vale.Math.Poly2.Defs_s.sum_of_bools (1 - k) (1 - m) g) /\
(forall (i: Prims.int). {:pattern f i} j <= i /\ i < k ==> f i == g (- i)))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f ==
Vale.Math.Poly2.Defs_s.sum_of_bools (1 - k) (1 - j) g)
(decreases m - j) | {
"end_col": 52,
"end_line": 109,
"start_col": 2,
"start_line": 109
} |
FStar.Pervasives.Lemma | val lemma_shift_is_mul (a: poly) (n: nat) : Lemma (shift a n =. a *. (monomial n)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem | val lemma_shift_is_mul (a: poly) (n: nat) : Lemma (shift a n =. a *. (monomial n))
let lemma_shift_is_mul (a: poly) (n: nat) : Lemma (shift a n =. a *. (monomial n)) = | false | null | true | let an = shift a n in
let b = monomial n in
let lem (k: nat) : Lemma (an.[ k ] == mul_element a b k) =
if k < n
then lemma_sum_of_zero 0 k (mul_element_fun a b k)
else lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.nat",
"FStar.Classical.forall_intro",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs_s.mul_element",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.poly_index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.lemma_sum_extend",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.monomial",
"Vale.Math.Poly2.Defs_s.shift",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_shift_is_mul (a: poly) (n: nat) : Lemma (shift a n =. a *. (monomial n)) | [] | Vale.Math.Poly2.Defs.lemma_shift_is_mul | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(ensures Vale.Math.Poly2.Defs_s.shift a n =. a *. Vale.Math.Poly2.Defs_s.monomial n) | {
"end_col": 34,
"end_line": 308,
"start_col": 82,
"start_line": 299
} |
FStar.Pervasives.Lemma | val lemma_mul_distribute (a b c: poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f | val lemma_mul_distribute (a b c: poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c))
let lemma_mul_distribute (a b c: poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) = | false | null | true | let f (k: nat)
: Lemma (ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k)) =
lemma_sum_of_pairs 0
(k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.mul_element",
"Vale.Math.Poly2.Defs.op_Plus_Dot",
"Prims.op_disEquality",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.add",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_of_pairs",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_distribute (a b c: poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) | [] | Vale.Math.Poly2.Defs.lemma_mul_distribute | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> c: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures a *. (b +. c) =. a *. b +. a *. c) | {
"end_col": 32,
"end_line": 291,
"start_col": 87,
"start_line": 282
} |
FStar.Pervasives.Lemma | val lemma_add_move (a b: poly) : Lemma (ensures a == (a +. b) +. b) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a | val lemma_add_move (a b: poly) : Lemma (ensures a == (a +. b) +. b)
let lemma_add_move (a b: poly) : Lemma (ensures a == (a +. b) +. b) = | false | null | true | lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Vale.Math.Poly2.Defs.lemma_add_zero",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_add_cancel",
"Vale.Math.Poly2.Defs.lemma_add_associate",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Defs.op_Plus_Dot",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = () | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_add_move (a b: poly) : Lemma (ensures a == (a +. b) +. b) | [] | Vale.Math.Poly2.Defs.lemma_add_move | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures a == a +. b +. b) | {
"end_col": 18,
"end_line": 47,
"start_col": 2,
"start_line": 45
} |
FStar.Pervasives.Lemma | val lemma_mul_element (a b: poly) (k: int)
: Lemma (requires True) (ensures (a *. b).[ k ] == mul_element a b k) [SMTPat (a *. b).[ k ]] | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k) | val lemma_mul_element (a b: poly) (k: int)
: Lemma (requires True) (ensures (a *. b).[ k ] == mul_element a b k) [SMTPat (a *. b).[ k ]]
let lemma_mul_element (a b: poly) (k: int)
: Lemma (requires True) (ensures (a *. b).[ k ] == mul_element a b k) [SMTPat (a *. b).[ k ]] = | false | null | true | if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Addition",
"FStar.Seq.Base.length",
"Prims.bool",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Vale.Math.Poly2.Defs_s.mul_element",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]] | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_element (a b: poly) (k: int)
: Lemma (requires True) (ensures (a *. b).[ k ] == mul_element a b k) [SMTPat (a *. b).[ k ]] | [] | Vale.Math.Poly2.Defs.lemma_mul_element | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> k: Prims.int
-> FStar.Pervasives.Lemma (ensures (a *. b).[ k ] == Vale.Math.Poly2.Defs_s.mul_element a b k)
[SMTPat (a *. b).[ k ]] | {
"end_col": 86,
"end_line": 228,
"start_col": 2,
"start_line": 228
} |
FStar.Pervasives.Lemma | val lemma_mul_one (a: poly) : Lemma ((a *. one) =. a) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f | val lemma_mul_one (a: poly) : Lemma ((a *. one) =. a)
let lemma_mul_one (a: poly) : Lemma ((a *. one) =. a) = | false | null | true | let f (k: nat) : Lemma (mul_element a one k == a.[ k ]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.mul_element",
"Vale.Math.Poly2.Defs_s.one",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.poly_index",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_one (a: poly) : Lemma ((a *. one) =. a) | [] | Vale.Math.Poly2.Defs.lemma_mul_one | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures a *. Vale.Math.Poly2.Defs_s.one =. a) | {
"end_col": 32,
"end_line": 240,
"start_col": 54,
"start_line": 236
} |
FStar.Pervasives.Lemma | val lemma_mul_zero (a: poly) : Lemma ((a *. zero) =. zero) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f | val lemma_mul_zero (a: poly) : Lemma ((a *. zero) =. zero)
let lemma_mul_zero (a: poly) : Lemma ((a *. zero) =. zero) = | false | null | true | let f (k: nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.b2t",
"Prims.op_Negation",
"Vale.Math.Poly2.Defs_s.mul_element",
"Vale.Math.Poly2.Defs_s.zero",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_zero (a: poly) : Lemma ((a *. zero) =. zero) | [] | Vale.Math.Poly2.Defs.lemma_mul_zero | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma
(ensures a *. Vale.Math.Poly2.Defs_s.zero =. Vale.Math.Poly2.Defs_s.zero) | {
"end_col": 32,
"end_line": 234,
"start_col": 59,
"start_line": 230
} |
FStar.Pervasives.Lemma | val lemma_mul_degree (a b: poly)
: Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else - 1)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1))
=
if degree a >= 0 && degree b >= 0 then
(
let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[len - 1]);
assert ((a *. b).[len - 2]);
()
)
else if degree a < 0 then
(
assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
assert (b =. zero);
lemma_mul_zero a;
()
) | val lemma_mul_degree (a b: poly)
: Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else - 1))
let lemma_mul_degree (a b: poly)
: Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else - 1)) = | false | null | true | if degree a >= 0 && degree b >= 0
then
(let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[ len - 1 ]);
assert ((a *. b).[ len - 2 ]);
())
else
if degree a < 0
then
(assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
())
else
(assert (b =. zero);
lemma_mul_zero a;
()) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.op_AmpAmp",
"Prims.op_GreaterThanOrEqual",
"Vale.Math.Poly2.Defs_s.degree",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Prims.op_Subtraction",
"Prims.op_Negation",
"Vale.Math.Poly2.Defs.lemma_sum_extend",
"FStar.Seq.Base.length",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Prims.int",
"Prims.op_Addition",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_mul_commute",
"Vale.Math.Poly2.Defs_s.zero",
"Vale.Math.Poly2.Defs.lemma_mul_zero",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.op_Minus",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b
let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem
let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_degree (a b: poly)
: Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else - 1)) | [] | Vale.Math.Poly2.Defs.lemma_mul_degree | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma
(ensures
Vale.Math.Poly2.Defs_s.degree (a *. b) ==
(match Vale.Math.Poly2.Defs_s.degree a >= 0 && Vale.Math.Poly2.Defs_s.degree b >= 0 with
| true -> Vale.Math.Poly2.Defs_s.degree a + Vale.Math.Poly2.Defs_s.degree b
| _ -> - 1)) | {
"end_col": 3,
"end_line": 334,
"start_col": 2,
"start_line": 313
} |
FStar.Pervasives.Lemma | val lemma_sum_swap (j k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
(forall (x: int). {:pattern (f x)}
j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y: int). {:pattern (g y)}
j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)} ff x y == gg y x))
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
) | val lemma_sum_swap (j k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
(forall (x: int). {:pattern (f x)}
j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y: int). {:pattern (g y)}
j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)} ff x y == gg y x))
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
let rec lemma_sum_swap (j k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
(forall (x: int). {:pattern (f x)}
j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y: int). {:pattern (g y)}
j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)} ff x y == gg y x))
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j)) = | false | null | true | if (j < k)
then
(let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g';
lemma_sum_swap j k1 ff gg f1 g1;
lemma_sum_of_pairs j k1 f f1 f';
lemma_sum_of_pairs j k1 g g1 g') | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Prims.int",
"Prims.bool",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.lemma_sum_of_pairs",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_sum_swap",
"Vale.Math.Poly2.Defs.lemma_sum_reverse",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.eq2",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_swap (j k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
(forall (x: int). {:pattern (f x)}
j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y: int). {:pattern (g y)}
j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)} ff x y == gg y x))
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_sum_swap | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
j: Prims.int ->
k: Prims.int ->
ff: (_: Prims.int -> _: Prims.int -> Prims.bool) ->
gg: (_: Prims.int -> _: Prims.int -> Prims.bool) ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires
(forall (x: Prims.int). {:pattern f x}
j <= x /\ x < k ==> f x == Vale.Math.Poly2.Defs_s.sum_of_bools j (j + k - x) (ff x)) /\
(forall (y: Prims.int). {:pattern g y}
j <= y /\ y < k ==> g y == Vale.Math.Poly2.Defs_s.sum_of_bools j (j + k - y) (gg y)) /\
(forall (x: Prims.int) (y: Prims.int). {:pattern ff x y} ff x y == gg y x))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools j k f == Vale.Math.Poly2.Defs_s.sum_of_bools j k g)
(decreases k - j) | {
"end_col": 3,
"end_line": 158,
"start_col": 2,
"start_line": 141
} |
FStar.Pervasives.Lemma | val lemma_sum_swap_mul_associate (k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
k > 0 /\ (forall (x: nat). {:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y: nat). {:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)}
ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x: int) (y: int). {:pattern (ff x y)\/(gg y x)} ff x y == gg y x))
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
() | val lemma_sum_swap_mul_associate (k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
k > 0 /\ (forall (x: nat). {:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y: nat). {:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)}
ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x: int) (y: int). {:pattern (ff x y)\/(gg y x)} ff x y == gg y x))
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
let lemma_sum_swap_mul_associate (k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
k > 0 /\ (forall (x: nat). {:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y: nat). {:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)}
ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x: int) (y: int). {:pattern (ff x y)\/(gg y x)} ff x y == gg y x))
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g) = | false | null | true | let k' = k + k - 1 in
let lemma_f (x: nat)
: Lemma (ensures (k <= x ==> not (f x)) /\ (x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))) =
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y: nat)
: Lemma (ensures (k <= y ==> not (g y)) /\ (y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))) =
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
() | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Prims.int",
"Prims.bool",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_sum_extend",
"Vale.Math.Poly2.Defs.lemma_sum_swap",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Negation",
"Prims.op_LessThan",
"Prims.eq2",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.op_Subtraction",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_of_zero",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs.lemma_sum_join",
"Prims.op_GreaterThan",
"Prims.l_Forall"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_sum_swap_mul_associate (k: int) (ff gg: (int -> int -> bool)) (f g: (int -> bool))
: Lemma
(requires
k > 0 /\ (forall (x: nat). {:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y: nat). {:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x: int) (y: int). {:pattern (ff x y)}
ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x: int) (y: int). {:pattern (ff x y)\/(gg y x)} ff x y == gg y x))
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g) | [] | Vale.Math.Poly2.Defs.lemma_sum_swap_mul_associate | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
k: Prims.int ->
ff: (_: Prims.int -> _: Prims.int -> Prims.bool) ->
gg: (_: Prims.int -> _: Prims.int -> Prims.bool) ->
f: (_: Prims.int -> Prims.bool) ->
g: (_: Prims.int -> Prims.bool)
-> FStar.Pervasives.Lemma
(requires
k > 0 /\
(forall (x: Prims.nat). {:pattern f x}
f x == Vale.Math.Poly2.Defs_s.sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y: Prims.nat). {:pattern g y} g y == Vale.Math.Poly2.Defs_s.sum_of_bools y k (gg y)
) /\
(forall (x: Prims.int) (y: Prims.int). {:pattern ff x y}
ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x: Prims.int) (y: Prims.int). {:pattern ff x y\/gg y x} ff x y == gg y x))
(ensures
Vale.Math.Poly2.Defs_s.sum_of_bools 0 k f == Vale.Math.Poly2.Defs_s.sum_of_bools 0 k g) | {
"end_col": 4,
"end_line": 208,
"start_col": 3,
"start_line": 170
} |
FStar.Pervasives.Lemma | val lemma_mul_associate (a b c: poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f | val lemma_mul_associate (a b c: poly) : Lemma (a *. (b *. c) =. (a *. b) *. c)
let lemma_mul_associate (a b c: poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) = | false | null | true | let f (k: nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i j: int) = a.[ j ] && b.[ i - j ] && c.[ k - i ] in
let abc2 (j i: int) = a.[ j ] && b.[ i - j ] && c.[ k - i ] in
let abc3 (j i: int) = a.[ j ] && b.[ i ] && c.[ k - j - i ] in
let sum_abc1 (i: int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j: int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j: int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i: int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[ k - i ] (abc1 i) (mul_element_fun a b i)
in
let l2 (j: int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j: int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[ j ] (abc3 j) (mul_element_fun b c (k - j))
in
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
()
in
FStar.Classical.forall_intro f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"FStar.Classical.forall_intro",
"Prims.nat",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.mul_element",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Vale.Math.Poly2.Defs_s.mul",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Vale.Math.Poly2.Defs.lemma_sum_pointwise_equal",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs.lemma_sum_swap_mul_associate",
"Prims.int",
"Vale.Math.Poly2.Defs.lemma_sum_mul",
"Prims.op_Subtraction",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs.lemma_sum_shift",
"Vale.Math.Poly2.Defs_s.sum_of_bools",
"Prims.op_AmpAmp",
"Vale.Math.Poly2.Defs.op_Equals_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_associate (a b c: poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) | [] | Vale.Math.Poly2.Defs.lemma_mul_associate | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> c: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (ensures a *. (b *. c) =. a *. b *. c) | {
"end_col": 32,
"end_line": 280,
"start_col": 79,
"start_line": 248
} |
FStar.Pervasives.Lemma | val lemma_mod_degree (a b: poly)
: Lemma (requires length b > 0) (ensures degree (a %. b) < degree b) (decreases (length a)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_mod_degree (a b:poly) : Lemma
(requires length b > 0)
(ensures degree (a %. b) < degree b)
(decreases (length a))
=
if length a >= length b then
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = add a (shift b n) in
lemma_mod_degree a' b
) | val lemma_mod_degree (a b: poly)
: Lemma (requires length b > 0) (ensures degree (a %. b) < degree b) (decreases (length a))
let rec lemma_mod_degree (a b: poly)
: Lemma (requires length b > 0) (ensures degree (a %. b) < degree b) (decreases (length a)) = | false | null | true | if length a >= length b
then
(let _ = assert (a.[ length a - 1 ]) in
let n = length a - length b in
let a' = add a (shift b n) in
lemma_mod_degree a' b) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"Prims.bool",
"Vale.Math.Poly2.Defs.lemma_mod_degree",
"Vale.Math.Poly2.Defs_s.add",
"Vale.Math.Poly2.Defs_s.shift",
"Prims.int",
"Prims.op_Subtraction",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Prims.op_GreaterThan",
"Prims.squash",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs_s.degree",
"Vale.Math.Poly2.Defs.op_Percent_Dot",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b
let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem
let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1))
=
if degree a >= 0 && degree b >= 0 then
(
let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[len - 1]);
assert ((a *. b).[len - 2]);
()
)
else if degree a < 0 then
(
assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
assert (b =. zero);
lemma_mul_zero a;
()
)
let lemma_mul_reverse (a b:poly) (n:nat) : Lemma
(requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n)
=
let ab = a *. b in
let rab = reverse ab (n + n) in
let ra = reverse a n in
let rb = reverse b n in
lemma_mul_degree a b;
lemma_mul_degree ra rb;
let f (k:int) : Lemma (rab.[k] == (ra *. rb).[k]) =
if 0 <= k && k <= n + n then
(
let f0 = mul_element_fun ra rb k in
let f1 (i:int) : bool = a.[n + i] && b.[n - k - i] in
let f2 = mul_element_fun a b (n + n - k) in
// mul_element a b (n + n - k) == sum_of_bools 0 (n + n + 1 - k) f2
// mul_element ra rb k == sum_of_bools 0 (k + 1) f0
lemma_sum_invert 0 (k + 1) f0 f1;
// mul_element ra rb k == sum_of_bools (-k) 1 f1
lemma_sum_shift (-k) 1 n f1 f2;
// mul_element ra rb k == sum_of_bools (n - k) (n + 1) f2
let lo = min (n - k) 0 in
let hi = max (n + 1) (n + n + 1 - k) in
lemma_sum_extend lo 0 (n + n + 1 - k) hi f2;
lemma_sum_extend lo (n - k) (n + 1) hi f2;
()
)
in
lemma_pointwise_equal rab (ra *. rb) f
// DIVISION, MOD
let rec lemma_div_mod (a b:poly) : Lemma
(requires length b > 0)
(ensures a =. (a /. b) *. b +. (a %. b))
(decreases (length a))
=
if length a < length b then
(
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = a +. (shift b n) in
let xn = monomial n in
lemma_shift_is_mul b n;
lemma_mul_commute b xn;
// a' == a +. xn *. b
// (a /. b == a' /. b +. xn);
lemma_add_move (a' /. b) xn;
// (a' /. b == a /. b +. xn);
lemma_div_mod a' b;
// a' == (a' /. b) *. b +. (a' %. b)
// a +. xn * b == (a /. b + xn) *. b +. (a %. b))
lemma_mul_distribute_left (a /. b) xn b;
// a +. xn *. b == (a /. b) *. b +. xn *. b +. (a %. b)
// a == (a /. b) *. b +. (a %. b)
()
)
let rec lemma_div_degree (a b:poly) : Lemma
(requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then -1 else degree a - degree b))
(decreases (length a))
=
if length a >= length b then
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = add a (shift b n) in
lemma_div_degree a' b;
assert ((a /. b).[degree a - degree b]);
()
)
let rec lemma_mod_degree (a b:poly) : Lemma
(requires length b > 0)
(ensures degree (a %. b) < degree b)
(decreases (length a)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mod_degree (a b: poly)
: Lemma (requires length b > 0) (ensures degree (a %. b) < degree b) (decreases (length a)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_mod_degree | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b > 0)
(ensures Vale.Math.Poly2.Defs_s.degree (a %. b) < Vale.Math.Poly2.Defs_s.degree b)
(decreases FStar.Seq.Base.length a) | {
"end_col": 3,
"end_line": 431,
"start_col": 2,
"start_line": 425
} |
FStar.Pervasives.Lemma | val lemma_div_degree (a b: poly)
: Lemma (requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then - 1 else degree a - degree b))
(decreases (length a)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_div_degree (a b:poly) : Lemma
(requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then -1 else degree a - degree b))
(decreases (length a))
=
if length a >= length b then
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = add a (shift b n) in
lemma_div_degree a' b;
assert ((a /. b).[degree a - degree b]);
()
) | val lemma_div_degree (a b: poly)
: Lemma (requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then - 1 else degree a - degree b))
(decreases (length a))
let rec lemma_div_degree (a b: poly)
: Lemma (requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then - 1 else degree a - degree b))
(decreases (length a)) = | false | null | true | if length a >= length b
then
(let _ = assert (a.[ length a - 1 ]) in
let n = length a - length b in
let a' = add a (shift b n) in
lemma_div_degree a' b;
assert ((a /. b).[ degree a - degree b ]);
()) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"Prims.bool",
"Prims.unit",
"Prims._assert",
"Prims.b2t",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs.op_Slash_Dot",
"Prims.op_Subtraction",
"Vale.Math.Poly2.Defs_s.degree",
"Vale.Math.Poly2.Defs.lemma_div_degree",
"Vale.Math.Poly2.Defs_s.add",
"Vale.Math.Poly2.Defs_s.shift",
"Prims.int",
"Prims.op_GreaterThan",
"Prims.squash",
"Prims.eq2",
"Prims.op_LessThan",
"Prims.op_Minus",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b
let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem
let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1))
=
if degree a >= 0 && degree b >= 0 then
(
let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[len - 1]);
assert ((a *. b).[len - 2]);
()
)
else if degree a < 0 then
(
assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
assert (b =. zero);
lemma_mul_zero a;
()
)
let lemma_mul_reverse (a b:poly) (n:nat) : Lemma
(requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n)
=
let ab = a *. b in
let rab = reverse ab (n + n) in
let ra = reverse a n in
let rb = reverse b n in
lemma_mul_degree a b;
lemma_mul_degree ra rb;
let f (k:int) : Lemma (rab.[k] == (ra *. rb).[k]) =
if 0 <= k && k <= n + n then
(
let f0 = mul_element_fun ra rb k in
let f1 (i:int) : bool = a.[n + i] && b.[n - k - i] in
let f2 = mul_element_fun a b (n + n - k) in
// mul_element a b (n + n - k) == sum_of_bools 0 (n + n + 1 - k) f2
// mul_element ra rb k == sum_of_bools 0 (k + 1) f0
lemma_sum_invert 0 (k + 1) f0 f1;
// mul_element ra rb k == sum_of_bools (-k) 1 f1
lemma_sum_shift (-k) 1 n f1 f2;
// mul_element ra rb k == sum_of_bools (n - k) (n + 1) f2
let lo = min (n - k) 0 in
let hi = max (n + 1) (n + n + 1 - k) in
lemma_sum_extend lo 0 (n + n + 1 - k) hi f2;
lemma_sum_extend lo (n - k) (n + 1) hi f2;
()
)
in
lemma_pointwise_equal rab (ra *. rb) f
// DIVISION, MOD
let rec lemma_div_mod (a b:poly) : Lemma
(requires length b > 0)
(ensures a =. (a /. b) *. b +. (a %. b))
(decreases (length a))
=
if length a < length b then
(
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = a +. (shift b n) in
let xn = monomial n in
lemma_shift_is_mul b n;
lemma_mul_commute b xn;
// a' == a +. xn *. b
// (a /. b == a' /. b +. xn);
lemma_add_move (a' /. b) xn;
// (a' /. b == a /. b +. xn);
lemma_div_mod a' b;
// a' == (a' /. b) *. b +. (a' %. b)
// a +. xn * b == (a /. b + xn) *. b +. (a %. b))
lemma_mul_distribute_left (a /. b) xn b;
// a +. xn *. b == (a /. b) *. b +. xn *. b +. (a %. b)
// a == (a /. b) *. b +. (a %. b)
()
)
let rec lemma_div_degree (a b:poly) : Lemma
(requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then -1 else degree a - degree b))
(decreases (length a)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_div_degree (a b: poly)
: Lemma (requires length b > 0)
(ensures degree (a /. b) == (if degree a < degree b then - 1 else degree a - degree b))
(decreases (length a)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_div_degree | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b > 0)
(ensures
Vale.Math.Poly2.Defs_s.degree (a /. b) ==
(match Vale.Math.Poly2.Defs_s.degree a < Vale.Math.Poly2.Defs_s.degree b with
| true -> - 1
| _ -> Vale.Math.Poly2.Defs_s.degree a - Vale.Math.Poly2.Defs_s.degree b))
(decreases FStar.Seq.Base.length a) | {
"end_col": 3,
"end_line": 418,
"start_col": 2,
"start_line": 410
} |
FStar.Pervasives.Lemma | val lemma_div_mod (a b: poly)
: Lemma (requires length b > 0) (ensures a =. (a /. b) *. b +. (a %. b)) (decreases (length a)) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_div_mod (a b:poly) : Lemma
(requires length b > 0)
(ensures a =. (a /. b) *. b +. (a %. b))
(decreases (length a))
=
if length a < length b then
(
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
let _ = assert (a.[length a - 1]) in
let n = length a - length b in
let a' = a +. (shift b n) in
let xn = monomial n in
lemma_shift_is_mul b n;
lemma_mul_commute b xn;
// a' == a +. xn *. b
// (a /. b == a' /. b +. xn);
lemma_add_move (a' /. b) xn;
// (a' /. b == a /. b +. xn);
lemma_div_mod a' b;
// a' == (a' /. b) *. b +. (a' %. b)
// a +. xn * b == (a /. b + xn) *. b +. (a %. b))
lemma_mul_distribute_left (a /. b) xn b;
// a +. xn *. b == (a /. b) *. b +. xn *. b +. (a %. b)
// a == (a /. b) *. b +. (a %. b)
()
) | val lemma_div_mod (a b: poly)
: Lemma (requires length b > 0) (ensures a =. (a /. b) *. b +. (a %. b)) (decreases (length a))
let rec lemma_div_mod (a b: poly)
: Lemma (requires length b > 0) (ensures a =. (a /. b) *. b +. (a %. b)) (decreases (length a)) = | false | null | true | if length a < length b
then
(lemma_mul_zero b;
lemma_mul_commute b zero;
())
else
(let _ = assert (a.[ length a - 1 ]) in
let n = length a - length b in
let a' = a +. (shift b n) in
let xn = monomial n in
lemma_shift_is_mul b n;
lemma_mul_commute b xn;
lemma_add_move (a' /. b) xn;
lemma_div_mod a' b;
lemma_mul_distribute_left (a /. b) xn b;
()) | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma",
""
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.op_LessThan",
"FStar.Seq.Base.length",
"Prims.bool",
"Prims.unit",
"Vale.Math.Poly2.Defs.lemma_mul_commute",
"Vale.Math.Poly2.Defs_s.zero",
"Vale.Math.Poly2.Defs.lemma_mul_zero",
"Vale.Math.Poly2.Defs.lemma_mul_distribute_left",
"Vale.Math.Poly2.Defs.op_Slash_Dot",
"Vale.Math.Poly2.Defs.lemma_div_mod",
"Vale.Math.Poly2.Defs.lemma_add_move",
"Vale.Math.Poly2.Defs.lemma_shift_is_mul",
"Vale.Math.Poly2.Defs_s.monomial",
"Vale.Math.Poly2.Defs.op_Plus_Dot",
"Vale.Math.Poly2.Defs_s.shift",
"Prims.int",
"Prims.op_Subtraction",
"Prims._assert",
"Prims.b2t",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Prims.op_GreaterThan",
"Prims.squash",
"Vale.Math.Poly2.Defs.op_Equals_Dot",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Vale.Math.Poly2.Defs.op_Percent_Dot",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b
let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem
let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1))
=
if degree a >= 0 && degree b >= 0 then
(
let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[len - 1]);
assert ((a *. b).[len - 2]);
()
)
else if degree a < 0 then
(
assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
assert (b =. zero);
lemma_mul_zero a;
()
)
let lemma_mul_reverse (a b:poly) (n:nat) : Lemma
(requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n)
=
let ab = a *. b in
let rab = reverse ab (n + n) in
let ra = reverse a n in
let rb = reverse b n in
lemma_mul_degree a b;
lemma_mul_degree ra rb;
let f (k:int) : Lemma (rab.[k] == (ra *. rb).[k]) =
if 0 <= k && k <= n + n then
(
let f0 = mul_element_fun ra rb k in
let f1 (i:int) : bool = a.[n + i] && b.[n - k - i] in
let f2 = mul_element_fun a b (n + n - k) in
// mul_element a b (n + n - k) == sum_of_bools 0 (n + n + 1 - k) f2
// mul_element ra rb k == sum_of_bools 0 (k + 1) f0
lemma_sum_invert 0 (k + 1) f0 f1;
// mul_element ra rb k == sum_of_bools (-k) 1 f1
lemma_sum_shift (-k) 1 n f1 f2;
// mul_element ra rb k == sum_of_bools (n - k) (n + 1) f2
let lo = min (n - k) 0 in
let hi = max (n + 1) (n + n + 1 - k) in
lemma_sum_extend lo 0 (n + n + 1 - k) hi f2;
lemma_sum_extend lo (n - k) (n + 1) hi f2;
()
)
in
lemma_pointwise_equal rab (ra *. rb) f
// DIVISION, MOD
let rec lemma_div_mod (a b:poly) : Lemma
(requires length b > 0)
(ensures a =. (a /. b) *. b +. (a %. b))
(decreases (length a)) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_div_mod (a b: poly)
: Lemma (requires length b > 0) (ensures a =. (a /. b) *. b +. (a %. b)) (decreases (length a)) | [
"recursion"
] | Vale.Math.Poly2.Defs.lemma_div_mod | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly
-> FStar.Pervasives.Lemma (requires FStar.Seq.Base.length b > 0)
(ensures a =. a /. b *. b +. a %. b)
(decreases FStar.Seq.Base.length a) | {
"end_col": 3,
"end_line": 403,
"start_col": 2,
"start_line": 378
} |
FStar.Pervasives.Lemma | val lemma_mul_reverse (a b: poly) (n: nat)
: Lemma (requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n) | [
{
"abbrev": false,
"full_module": "Vale.Math.Poly2.Defs_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Math.Poly2",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mul_reverse (a b:poly) (n:nat) : Lemma
(requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n)
=
let ab = a *. b in
let rab = reverse ab (n + n) in
let ra = reverse a n in
let rb = reverse b n in
lemma_mul_degree a b;
lemma_mul_degree ra rb;
let f (k:int) : Lemma (rab.[k] == (ra *. rb).[k]) =
if 0 <= k && k <= n + n then
(
let f0 = mul_element_fun ra rb k in
let f1 (i:int) : bool = a.[n + i] && b.[n - k - i] in
let f2 = mul_element_fun a b (n + n - k) in
// mul_element a b (n + n - k) == sum_of_bools 0 (n + n + 1 - k) f2
// mul_element ra rb k == sum_of_bools 0 (k + 1) f0
lemma_sum_invert 0 (k + 1) f0 f1;
// mul_element ra rb k == sum_of_bools (-k) 1 f1
lemma_sum_shift (-k) 1 n f1 f2;
// mul_element ra rb k == sum_of_bools (n - k) (n + 1) f2
let lo = min (n - k) 0 in
let hi = max (n + 1) (n + n + 1 - k) in
lemma_sum_extend lo 0 (n + n + 1 - k) hi f2;
lemma_sum_extend lo (n - k) (n + 1) hi f2;
()
)
in
lemma_pointwise_equal rab (ra *. rb) f | val lemma_mul_reverse (a b: poly) (n: nat)
: Lemma (requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n)
let lemma_mul_reverse (a b: poly) (n: nat)
: Lemma (requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n) = | false | null | true | let ab = a *. b in
let rab = reverse ab (n + n) in
let ra = reverse a n in
let rb = reverse b n in
lemma_mul_degree a b;
lemma_mul_degree ra rb;
let f (k: int) : Lemma (rab.[ k ] == (ra *. rb).[ k ]) =
if 0 <= k && k <= n + n
then
(let f0 = mul_element_fun ra rb k in
let f1 (i: int) : bool = a.[ n + i ] && b.[ n - k - i ] in
let f2 = mul_element_fun a b (n + n - k) in
lemma_sum_invert 0 (k + 1) f0 f1;
lemma_sum_shift (- k) 1 n f1 f2;
let lo = min (n - k) 0 in
let hi = max (n + 1) (n + n + 1 - k) in
lemma_sum_extend lo 0 (n + n + 1 - k) hi f2;
lemma_sum_extend lo (n - k) (n + 1) hi f2;
())
in
lemma_pointwise_equal rab (ra *. rb) f | {
"checked_file": "Vale.Math.Poly2.Defs.fst.checked",
"dependencies": [
"Vale.Math.Poly2.Defs_s.fst.checked",
"Vale.Def.Prop_s.fst.checked",
"prims.fst.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lib.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Math.Poly2.Defs.fst"
} | [
"lemma"
] | [
"Vale.Math.Poly2.Defs_s.poly",
"Prims.nat",
"Vale.Math.Poly2.Defs.lemma_pointwise_equal",
"Vale.Math.Poly2.Defs.op_Star_Dot",
"Prims.int",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.bool",
"Vale.Math.Poly2.Defs_s.poly_index",
"Vale.Math.Poly2.Defs_s.mul",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Vale.Math.Poly2.Defs.lemma_sum_extend",
"Prims.op_Subtraction",
"Prims.l_and",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Equality",
"Prims.op_LessThan",
"Vale.Math.Poly2.Defs.max",
"Prims.min",
"Vale.Math.Poly2.Defs.lemma_sum_shift",
"Prims.op_Minus",
"Vale.Math.Poly2.Defs.lemma_sum_invert",
"Vale.Math.Poly2.Defs_s.mul_element_fun",
"Vale.Math.Poly2.Defs_s.op_String_Access",
"Vale.Math.Poly2.Defs.lemma_mul_degree",
"Vale.Math.Poly2.Defs_s.reverse",
"Vale.Math.Poly2.Defs_s.degree",
"Vale.Math.Poly2.Defs.op_Equals_Dot"
] | [] | module Vale.Math.Poly2.Defs
open FStar.Mul
open Vale.Def.Prop_s
open FStar.Seq
open Vale.Math.Poly2.Defs_s
unfold let max = FStar.Math.Lib.max
#reset-options "--z3rlimit 10"
let poly_equal (a b:poly) : prop0 =
(forall (i:nat).{:pattern a.[i] \/ b.[i]} a.[i] == b.[i])
unfold let ( =. ) = poly_equal
unfold let ( +. ) = add
unfold let ( *. ) = mul
unfold let ( /. ) = div
unfold let ( %. ) = mod
let lemma_poly_equal_elim (a b:poly) : Lemma
(requires a =. b)
(ensures a == b)
(decreases (length a + length b))
[SMTPat (poly_equal a b)]
=
let len = max (length a) (length b) in
assert (len > 0 ==> a.[len - 1] == b.[len - 1]);
assert (length a == length b);
assert (forall (i:nat).{:pattern (index a i) \/ (index b i)} a.[i] == b.[i]);
assert (equal a b)
let lemma_pointwise_equal (a b:poly) (pf:(i:int -> Lemma (a.[i] == b.[i]))) : Lemma (a == b) =
FStar.Classical.forall_intro pf;
lemma_poly_equal_elim a b
// ADDITION
let lemma_add_zero (a:poly) : Lemma ((a +. zero) =. a) = ()
let lemma_add_cancel (a:poly) : Lemma ((a +. a) =. zero) = ()
let lemma_add_cancel_eq (a b:poly) : Lemma (requires (a +. b) == zero) (ensures a =. b) = ()
let lemma_add_commute (a b:poly) : Lemma ((a +. b) =. (b +. a)) = ()
let lemma_add_associate (a b c:poly) : Lemma ((a +. (b +. c)) =. ((a +. b) +. c)) = ()
let lemma_add_move (a b:poly) : Lemma (ensures a == (a +. b) +. b) =
lemma_add_associate a b b;
lemma_add_cancel b;
lemma_add_zero a
// SUMMATION
let lemma_sum_empty (j:int) (f:int -> bool) : Lemma
(requires True)
(ensures not (sum_of_bools j j f))
[SMTPat (sum_of_bools j j f)]
=
()
let rec lemma_sum_of_zero (j k:int) (f:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> not (f i)))
(ensures not (sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_of_zero j (k - 1) f
let rec lemma_sum_join (i j k:int) (f:int -> bool) : Lemma
(requires i <= j /\ j <= k)
(ensures sum_of_bools i k f == (sum_of_bools i j f <> sum_of_bools j k f))
(decreases (k - j))
=
if j < k then lemma_sum_join i j (k - 1) f
let lemma_sum_extend (j' j k k':int) (f:int -> bool) : Lemma
(requires
j' <= j /\ j <= k /\ k <= k' /\
(forall (i:int).{:pattern (f i)} j' <= i /\ i < j ==> not (f i)) /\
(forall (i:int).{:pattern (f i)} k <= i /\ i < k' ==> not (f i))
)
(ensures sum_of_bools j' k' f == sum_of_bools j k f)
=
lemma_sum_of_zero j' j f;
lemma_sum_of_zero k k' f;
lemma_sum_join j' j k f;
lemma_sum_join j' k k' f
let rec lemma_sum_of_pairs (j k:int) (f g h:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (g i <> h i)))
(ensures sum_of_bools j k f == (sum_of_bools j k g <> sum_of_bools j k h))
(decreases (k - j))
=
if j < k then lemma_sum_of_pairs j (k - 1) f g h
let rec lemma_sum_shift (j k:int) (shift:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (i + shift)))
(ensures sum_of_bools j k f == sum_of_bools (j + shift) (k + shift) g)
(decreases (k - j))
=
if j < k then lemma_sum_shift j (k - 1) shift f g
let rec lemma_sum_invert_rec (j m k:int) (f g:int -> bool) : Lemma
(requires
j <= m /\ m <= k /\
sum_of_bools j k f == (sum_of_bools j m f <> sum_of_bools (1 - k) (1 - m) g) /\
(forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i))
)
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
(decreases (m - j))
=
if j < m then lemma_sum_invert_rec j (m - 1) k f g
let lemma_sum_invert (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (-i)))
(ensures sum_of_bools j k f == sum_of_bools (1 - k) (1 - j) g)
=
if j < k then lemma_sum_invert_rec j k k f g
let lemma_sum_reverse (j k:int) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == g (k + j - i - 1)))
(ensures sum_of_bools j k f == sum_of_bools j k g)
=
let f' (i:int) = f (-i) in
lemma_sum_invert j k f f';
lemma_sum_shift j k (1 - (k + j)) g f'
let rec lemma_sum_mul (j k:int) (b:bool) (f g:int -> bool) : Lemma
(requires (forall (i:int).{:pattern (f i)} j <= i /\ i < k ==> f i == (b && g i)))
(ensures sum_of_bools j k f == (b && sum_of_bools j k g))
(decreases (k - j))
=
if j < k then lemma_sum_mul j (k - 1) b f g
let rec lemma_sum_swap (j k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
(forall (x:int).{:pattern (f x)} j <= x /\ x < k ==> f x == sum_of_bools j (j + k - x) (ff x)) /\
(forall (y:int).{:pattern (g y)} j <= y /\ y < k ==> g y == sum_of_bools j (j + k - y) (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y == gg y x)
)
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if (j < k) then
(
let k1 = k - 1 in
let f1 x = sum_of_bools j (j + k1 - x) (ff x) in
let g1 y = sum_of_bools j (j + k1 - y) (gg y) in
let f' x = ff x (j + k1 - x) in
let g' y = gg y (j + k1 - y) in
lemma_sum_reverse j k f' g'; // summing f' and g' gives same answer, computed in reverse order
// sum_of_bools j k f' == sum_of_bools j k g'
// sum_of_bools j k1 f' + ff k1 j == sum_of_bools j k1 g' + gg k1 j
lemma_sum_swap j k1 ff gg f1 g1; // by induction: sum_of_bools j k1 f1 == sum_of_bools j k1 g1
// sum_of_bools j k1 f1 + (sum_of_bools j k1 f' + ff k1 j) == sum_of_bools j k1 g1 + (sum_of_bools j k1 g' + gg k1 j)
// (sum_of_bools j k1 f1 + sum_of_bools j k1 f') + ff k1 j == (sum_of_bools j k1 g1 + sum_of_bools j k1 g') + gg k1 j
lemma_sum_of_pairs j k1 f f1 f'; // sum_of_bools j k1 f1 + sum_of_bools j k1 f' == sum_of_bools j k1 f
lemma_sum_of_pairs j k1 g g1 g' // sum_of_bools j k1 g1 + sum_of_bools j k1 g' == sum_of_bools j k1 g
// sum_of_bools j k1 f + ff k1 j == sum_of_bools j k1 g + gg k1 j
// sum_of_bools j k f == sum_of_bools j k g
)
// Corollary for lemma_mul_associate
let lemma_sum_swap_mul_associate (k:int) (ff gg:int -> int -> bool) (f g:int -> bool) : Lemma
(requires
k > 0 /\
(forall (x:nat).{:pattern (f x)} f x == sum_of_bools 0 (x + 1) (ff x)) /\
(forall (y:nat).{:pattern (g y)} g y == sum_of_bools y k (gg y)) /\
(forall (x y:int).{:pattern (ff x y)} ff x y ==> 0 <= x /\ x < k /\ 0 <= y /\ y <= x) /\
(forall (x y:int).{:pattern (ff x y) \/ (gg y x)} ff x y == gg y x)
)
(ensures sum_of_bools 0 k f == sum_of_bools 0 k g)
=
// Example: k = 3, k' = 5, '#' shows non-zero elements of ff, '0'/'#' shows input to lemma_sum_swap:
// 0
// 00
// /|\ 00#
// | 0##0
// y ###00
//
// x -->
let k' = k + k - 1 in
let lemma_f (x:nat) : Lemma
(ensures
(k <= x ==> not (f x)) /\
(x < k' ==> f x == sum_of_bools 0 (k' - x) (ff x))
)
=
(if k <= x then lemma_sum_of_zero 0 (x + 1) (ff x));
lemma_sum_of_zero (if x < k then x + 1 else 0) (k' - x) (ff x);
(if x < k then lemma_sum_join 0 (x + 1) (k' - x) (ff x));
()
in
let lemma_g (y:nat) : Lemma
(ensures
(k <= y ==> not (g y)) /\
(y < k' ==> g y == sum_of_bools 0 (k' - y) (gg y))
)
=
(if k <= y then lemma_sum_of_zero 0 (y + 1) (gg y));
(if y < k then lemma_sum_of_zero 0 y (gg y));
lemma_sum_of_zero (if y < k then k else 0) (k' - y) (gg y);
(if y < k then lemma_sum_extend 0 y k (k' - y) (gg y));
()
in
FStar.Classical.forall_intro lemma_f;
FStar.Classical.forall_intro lemma_g;
lemma_sum_swap 0 k' ff gg f g;
lemma_sum_extend 0 0 k k' f;
lemma_sum_extend 0 0 k k' g;
()
let rec lemma_sum_pointwise_equal (j k:int) (f g:int -> bool) (pf:(i:int -> Lemma (f i == g i))) : Lemma
(ensures sum_of_bools j k f == sum_of_bools j k g)
(decreases (k - j))
=
if j < k then
(
pf (k - 1);
lemma_sum_pointwise_equal j (k - 1) f g pf
)
// MULTIPLICATION
let lemma_mul_element (a b:poly) (k:int) : Lemma
(requires True)
(ensures (a *. b).[k] == mul_element a b k)
[SMTPat (a *. b).[k]]
=
if k >= length a + length b then lemma_sum_of_zero 0 (k + 1) (mul_element_fun a b k)
let lemma_mul_zero (a:poly) : Lemma ((a *. zero) =. zero) =
let f (k:nat) : Lemma (not (mul_element a zero k)) =
lemma_sum_of_zero 0 (k + 1) (mul_element_fun a zero k)
in
FStar.Classical.forall_intro f
let lemma_mul_one (a:poly) : Lemma ((a *. one) =. a) =
let f (k:nat) : Lemma (mul_element a one k == a.[k]) =
lemma_sum_of_zero 0 k (mul_element_fun a one k)
in
FStar.Classical.forall_intro f
let lemma_mul_commute (a b:poly) : Lemma ((a *. b) =. (b *. a)) =
let f (k:nat) : Lemma (mul_element a b k == mul_element b a k) =
lemma_sum_reverse 0 (k + 1) (mul_element_fun a b k) (mul_element_fun b a k)
in
FStar.Classical.forall_intro f
let lemma_mul_associate (a b c:poly) : Lemma (a *. (b *. c) =. (a *. b) *. c) =
let f (k:nat) : Lemma (mul_element a (b *. c) k == mul_element (a *. b) c k) =
let abc1 (i:int) (j:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc2 (j:int) (i:int) = a.[j] && b.[i - j] && c.[k - i] in
let abc3 (j:int) (i:int) = a.[j] && b.[i] && c.[k - j - i] in
let sum_abc1 (i:int) = sum_of_bools 0 (i + 1) (abc1 i) in
let sum_abc2 (j:int) = sum_of_bools j (k + 1) (abc2 j) in
let sum_abc3 (j:int) = sum_of_bools 0 (k + 1 - j) (abc3 j) in
let l1 (i:int) : Lemma (mul_element_fun (a *. b) c k i == sum_abc1 i) =
lemma_sum_mul 0 (i + 1) c.[k - i] (abc1 i) (mul_element_fun a b i)
in
let l2 (j:int) : Lemma (sum_abc2 j == sum_abc3 j) =
lemma_sum_shift 0 (k + 1 - j) j (abc3 j) (abc2 j)
in
let l3 (j:int) : Lemma (mul_element_fun a (b *. c) k j == sum_abc3 j) =
lemma_sum_mul 0 (k + 1 - j) a.[j] (abc3 j) (mul_element_fun b c (k - j))
in
// mul_element (a *. b) c k
// sum[0 <= i <= k] (a *. b)[i] * c[k - i]
// sum[0 <= i <= k] (sum[0 <= j <= i] a[j] * b[i - j]) * c[k - i])
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun (a *. b) c k) sum_abc1 l1;
// sum[0 <= i <= k] sum[0 <= j <= i] a[j] * b[i - j] * c[k - i]
lemma_sum_swap_mul_associate (k + 1) abc1 abc2 sum_abc1 sum_abc2;
// sum[0 <= j <= k] sum[j <= i <= k] a[j] * b[i - j] * c[k - i]
lemma_sum_pointwise_equal 0 (k + 1) sum_abc2 sum_abc3 l2;
// sum[0 <= j <= k] sum[0 <= i <= k - j] a[j] * b[i] * c[k - j - i]
lemma_sum_pointwise_equal 0 (k + 1) (mul_element_fun a (b *. c) k) sum_abc3 l3;
// sum[0 <= j <= k] a[j] * (sum[0 <= i <= k - j] b[i] * c[k - j - i])
// sum[0 <= j <= k] (a[j] * (b *. c)[k - j])
// mul_element a (b *. c) k
()
in
FStar.Classical.forall_intro f
let lemma_mul_distribute (a b c:poly) : Lemma (a *. (b +. c) =. (a *. b) +. (a *. c)) =
let f (k:nat) : Lemma
(ensures mul_element a (b +. c) k == (mul_element a b k <> mul_element a c k))
=
lemma_sum_of_pairs 0 (k + 1)
(mul_element_fun a (b +. c) k)
(mul_element_fun a b k)
(mul_element_fun a c k)
in
FStar.Classical.forall_intro f
let lemma_mul_distribute_left (a b c:poly) : Lemma ((a +. b) *. c =. (a *. c) +. (b *. c)) =
lemma_mul_commute (a +. b) c;
lemma_mul_commute a c;
lemma_mul_commute b c;
lemma_mul_distribute c a b
let lemma_shift_is_mul (a:poly) (n:nat) : Lemma (shift a n =. a *. (monomial n)) =
let an = shift a n in
let b = monomial n in
let lem (k:nat) : Lemma (an.[k] == mul_element a b k) =
if k < n then
lemma_sum_of_zero 0 k (mul_element_fun a b k)
else
lemma_sum_extend 0 (k - n) (k - n + 1) (k + 1) (mul_element_fun a b k)
in
FStar.Classical.forall_intro lem
let lemma_mul_degree (a b:poly) : Lemma
(degree (a *. b) == (if degree a >= 0 && degree b >= 0 then degree a + degree b else -1))
=
if degree a >= 0 && degree b >= 0 then
(
let len = length a + length b in
lemma_sum_of_zero 0 len (mul_element_fun a b (len - 1));
lemma_sum_extend 0 (length a - 1) (length a) (len - 1) (mul_element_fun a b (len - 2));
assert (not (a *. b).[len - 1]);
assert ((a *. b).[len - 2]);
()
)
else if degree a < 0 then
(
assert (a =. zero);
lemma_mul_zero b;
lemma_mul_commute b zero;
()
)
else
(
assert (b =. zero);
lemma_mul_zero a;
()
)
let lemma_mul_reverse (a b:poly) (n:nat) : Lemma
(requires degree a <= n /\ degree b <= n) | false | false | Vale.Math.Poly2.Defs.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 10,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mul_reverse (a b: poly) (n: nat)
: Lemma (requires degree a <= n /\ degree b <= n)
(ensures reverse (a *. b) (n + n) =. reverse a n *. reverse b n) | [] | Vale.Math.Poly2.Defs.lemma_mul_reverse | {
"file_name": "vale/code/lib/math/Vale.Math.Poly2.Defs.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Vale.Math.Poly2.Defs_s.poly -> b: Vale.Math.Poly2.Defs_s.poly -> n: Prims.nat
-> FStar.Pervasives.Lemma
(requires Vale.Math.Poly2.Defs_s.degree a <= n /\ Vale.Math.Poly2.Defs_s.degree b <= n)
(ensures
Vale.Math.Poly2.Defs_s.reverse (a *. b) (n + n) =.
Vale.Math.Poly2.Defs_s.reverse a n *. Vale.Math.Poly2.Defs_s.reverse b n) | {
"end_col": 40,
"end_line": 367,
"start_col": 3,
"start_line": 339
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Vale.Transformers.PeepHole",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let movbe_elim_ph = {
ph = (function
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs in
let (dst, (src, ())) = oprs in
if OReg? dst then (
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
Some [mov; bswap]
) else None
| _ -> None);
input_hint = 1;
} | let movbe_elim_ph = | false | null | false | {
ph
=
(function
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs
in
let dst, (src, ()) = oprs in
if OReg? dst
then
(let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
Some [mov; bswap])
else None
| _ -> None);
input_hint = 1
} | {
"checked_file": "Vale.Transformers.MovbeElim.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.PeepHole.fsti.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.MovbeElim.fst"
} | [
"total"
] | [
"Vale.Transformers.PeepHole.Mkpre_peephole",
"Prims.list",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_MovBe64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_s.uu___is_OReg",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"FStar.Pervasives.Native.Some",
"Vale.X64.InsLemmas.make_instr_t",
"Vale.X64.InsLemmas.make_instr",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instructions_s.ins_Bswap64",
"Vale.X64.InsLemmas.make_instr_t_args",
"Vale.X64.Instructions_s.ins_Mov64",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.norm",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"FStar.Pervasives.delta_attr",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.Out",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.IOp64",
"Vale.Transformers.PeepHole.coerce_to_normal"
] | [] | module Vale.Transformers.MovbeElim
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Transformers.InstructionReorder
open Vale.X64.InsLemmas
open Vale.Transformers.PeepHole | false | true | Vale.Transformers.MovbeElim.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val movbe_elim_ph : Vale.Transformers.PeepHole.pre_peephole | [] | Vale.Transformers.MovbeElim.movbe_elim_ph | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.MovbeElim.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Transformers.PeepHole.pre_peephole | {
"end_col": 17,
"end_line": 26,
"start_col": 2,
"start_line": 15
} |
|
FStar.Pervasives.Lemma | val movbe_elim_correct (is: list ins) (s: machine_state)
: Lemma (peephole_correct movbe_elim_ph is s) [SMTPat (peephole_correct movbe_elim_ph is s)] | [
{
"abbrev": true,
"full_module": "Vale.Arch.Heap",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Vale.Def.Types_s",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.PeepHole",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let movbe_elim_correct (is:list ins) (s:machine_state) :
Lemma (peephole_correct movbe_elim_ph is s)
[SMTPat (peephole_correct movbe_elim_ph is s)] =
match is with
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs in
let (dst, (src, ())) = oprs in
if OReg? dst then (
let Some is' = movbe_elim_ph.ph is in
lemma_movbe_is_mov_bswap dst src s
) else ()
| _ -> () | val movbe_elim_correct (is: list ins) (s: machine_state)
: Lemma (peephole_correct movbe_elim_ph is s) [SMTPat (peephole_correct movbe_elim_ph is s)]
let movbe_elim_correct (is: list ins) (s: machine_state)
: Lemma (peephole_correct movbe_elim_ph is s) [SMTPat (peephole_correct movbe_elim_ph is s)] = | false | null | true | match is with
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs
in
let dst, (src, ()) = oprs in
if OReg? dst
then
(let Some is' = movbe_elim_ph.ph is in
lemma_movbe_is_mov_bswap dst src s)
| _ -> () | {
"checked_file": "Vale.Transformers.MovbeElim.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.PeepHole.fsti.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.MovbeElim.fst"
} | [
"lemma"
] | [
"Prims.list",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_state",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Prims.Cons",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instruction_s.op64",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_MovBe64",
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_s.uu___is_OReg",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Vale.Transformers.MovbeElim.lemma_movbe_is_mov_bswap",
"Prims.unit",
"FStar.Pervasives.Native.option",
"Vale.Transformers.PeepHole.__proj__Mkpre_peephole__item__ph",
"Vale.Transformers.MovbeElim.movbe_elim_ph",
"Prims.bool",
"FStar.Pervasives.norm",
"FStar.Pervasives.norm_step",
"FStar.Pervasives.zeta",
"FStar.Pervasives.iota",
"FStar.Pervasives.delta_attr",
"Prims.string",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Instruction_s.instr_operand_inout",
"Vale.X64.Instruction_s.Out",
"Vale.X64.Instruction_s.IOpEx",
"Vale.X64.Instruction_s.IOp64",
"Vale.Transformers.PeepHole.coerce_to_normal",
"Prims.l_True",
"Prims.squash",
"Vale.Transformers.PeepHole.peephole_correct",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat"
] | [] | module Vale.Transformers.MovbeElim
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Transformers.InstructionReorder
open Vale.X64.InsLemmas
open Vale.Transformers.PeepHole
let movbe_elim_ph = {
ph = (function
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs in
let (dst, (src, ())) = oprs in
if OReg? dst then (
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
Some [mov; bswap]
) else None
| _ -> None);
input_hint = 1;
}
module T = Vale.Def.Types_s
module H = Vale.Arch.Heap
#push-options "--initial_fuel 2 --max_fuel 2 --initial_ifuel 0 --max_ifuel 0"
let lemma_movbe_is_mov_bswap (dst src:operand64) (s:machine_state) :
Lemma
(requires (OReg? dst))
(ensures (
let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2)) =
let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s_movbe = machine_eval_ins movbe s in
let s_mov = machine_eval_ins mov s in
let s_bswap = machine_eval_ins bswap s_mov in
if valid_src_operand64_and_taint src s && valid_dst_operand64 dst s then (
let src_v = eval_operand src s in
let dst_movbe_v = T.reverse_bytes_nat64 src_v in
let dst_mov_v = eval_operand dst s_mov in
let dst_bswap_v = T.reverse_bytes_nat64 dst_mov_v in
if s_movbe.ms_ok then (
assert (Vale.X64.CPU_Features_s.movbe_enabled);
assert (s_movbe == update_operand64_preserve_flags'' dst dst_movbe_v s s);
assert (s_mov == update_operand64_preserve_flags'' dst src_v s s);
lemma_update_to_valid_destination_keeps_it_as_valid_src dst s src_v;
assert (eval_operand dst s_mov == src_v);
assert (valid_src_operand64_and_taint dst s_mov);
assert (s_bswap == update_operand64_preserve_flags'' dst dst_bswap_v s_mov s_mov);
assert (src_v == dst_mov_v);
assert (dst_movbe_v == dst_bswap_v);
lemma_double_update_reg dst s s_mov s_bswap s_movbe src_v dst_bswap_v
) else ()
) else (
assert (s_movbe == {s with ms_ok = false});
assert (s_mov == {s with ms_ok = false});
assert (s_bswap.ms_ok == false)
)
#pop-options
#push-options "--initial_fuel 3 --max_fuel 3 --initial_ifuel 0 --max_ifuel 0"
let movbe_elim_correct (is:list ins) (s:machine_state) :
Lemma (peephole_correct movbe_elim_ph is s) | false | false | Vale.Transformers.MovbeElim.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 3,
"initial_ifuel": 0,
"max_fuel": 3,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val movbe_elim_correct (is: list ins) (s: machine_state)
: Lemma (peephole_correct movbe_elim_ph is s) [SMTPat (peephole_correct movbe_elim_ph is s)] | [] | Vale.Transformers.MovbeElim.movbe_elim_correct | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.MovbeElim.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | is: Prims.list Vale.X64.Machine_Semantics_s.ins -> s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma
(ensures
Vale.Transformers.PeepHole.peephole_correct Vale.Transformers.MovbeElim.movbe_elim_ph is s)
[
SMTPat (Vale.Transformers.PeepHole.peephole_correct Vale.Transformers.MovbeElim.movbe_elim_ph
is
s)
] | {
"end_col": 11,
"end_line": 86,
"start_col": 2,
"start_line": 77
} |
FStar.Pervasives.Lemma | val lemma_movbe_is_mov_bswap (dst src: operand64) (s: machine_state)
: Lemma (requires (OReg? dst))
(ensures
(let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2)) | [
{
"abbrev": true,
"full_module": "Vale.Arch.Heap",
"short_module": "H"
},
{
"abbrev": true,
"full_module": "Vale.Def.Types_s",
"short_module": "T"
},
{
"abbrev": false,
"full_module": "Vale.Transformers.PeepHole",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.InsLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers.InstructionReorder",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Print_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instructions_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Instruction_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Transformers",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_movbe_is_mov_bswap (dst src:operand64) (s:machine_state) :
Lemma
(requires (OReg? dst))
(ensures (
let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2)) =
let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s_movbe = machine_eval_ins movbe s in
let s_mov = machine_eval_ins mov s in
let s_bswap = machine_eval_ins bswap s_mov in
if valid_src_operand64_and_taint src s && valid_dst_operand64 dst s then (
let src_v = eval_operand src s in
let dst_movbe_v = T.reverse_bytes_nat64 src_v in
let dst_mov_v = eval_operand dst s_mov in
let dst_bswap_v = T.reverse_bytes_nat64 dst_mov_v in
if s_movbe.ms_ok then (
assert (Vale.X64.CPU_Features_s.movbe_enabled);
assert (s_movbe == update_operand64_preserve_flags'' dst dst_movbe_v s s);
assert (s_mov == update_operand64_preserve_flags'' dst src_v s s);
lemma_update_to_valid_destination_keeps_it_as_valid_src dst s src_v;
assert (eval_operand dst s_mov == src_v);
assert (valid_src_operand64_and_taint dst s_mov);
assert (s_bswap == update_operand64_preserve_flags'' dst dst_bswap_v s_mov s_mov);
assert (src_v == dst_mov_v);
assert (dst_movbe_v == dst_bswap_v);
lemma_double_update_reg dst s s_mov s_bswap s_movbe src_v dst_bswap_v
) else ()
) else (
assert (s_movbe == {s with ms_ok = false});
assert (s_mov == {s with ms_ok = false});
assert (s_bswap.ms_ok == false)
) | val lemma_movbe_is_mov_bswap (dst src: operand64) (s: machine_state)
: Lemma (requires (OReg? dst))
(ensures
(let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2))
let lemma_movbe_is_mov_bswap (dst src: operand64) (s: machine_state)
: Lemma (requires (OReg? dst))
(ensures
(let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2)) = | false | null | true | let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s_movbe = machine_eval_ins movbe s in
let s_mov = machine_eval_ins mov s in
let s_bswap = machine_eval_ins bswap s_mov in
if valid_src_operand64_and_taint src s && valid_dst_operand64 dst s
then
(let src_v = eval_operand src s in
let dst_movbe_v = T.reverse_bytes_nat64 src_v in
let dst_mov_v = eval_operand dst s_mov in
let dst_bswap_v = T.reverse_bytes_nat64 dst_mov_v in
if s_movbe.ms_ok
then
(assert (Vale.X64.CPU_Features_s.movbe_enabled);
assert (s_movbe == update_operand64_preserve_flags'' dst dst_movbe_v s s);
assert (s_mov == update_operand64_preserve_flags'' dst src_v s s);
lemma_update_to_valid_destination_keeps_it_as_valid_src dst s src_v;
assert (eval_operand dst s_mov == src_v);
assert (valid_src_operand64_and_taint dst s_mov);
assert (s_bswap == update_operand64_preserve_flags'' dst dst_bswap_v s_mov s_mov);
assert (src_v == dst_mov_v);
assert (dst_movbe_v == dst_bswap_v);
lemma_double_update_reg dst s s_mov s_bswap s_movbe src_v dst_bswap_v))
else
(assert (s_movbe == { s with ms_ok = false });
assert (s_mov == { s with ms_ok = false });
assert (s_bswap.ms_ok == false)) | {
"checked_file": "Vale.Transformers.MovbeElim.fst.checked",
"dependencies": [
"Vale.X64.Print_s.fst.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Instructions_s.fsti.checked",
"Vale.X64.Instruction_s.fsti.checked",
"Vale.X64.InsLemmas.fsti.checked",
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Transformers.PeepHole.fsti.checked",
"Vale.Transformers.InstructionReorder.fst.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Transformers.MovbeElim.fst"
} | [
"lemma"
] | [
"Vale.X64.Machine_s.operand64",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.op_AmpAmp",
"Vale.X64.Machine_Semantics_s.valid_src_operand64_and_taint",
"Vale.X64.Machine_Semantics_s.valid_dst_operand64",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_ok",
"Vale.Transformers.PeepHole.lemma_double_update_reg",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Vale.Def.Types_s.nat64",
"Vale.X64.Machine_Semantics_s.update_operand64_preserve_flags''",
"Prims.b2t",
"Vale.X64.Machine_Semantics_s.eval_operand",
"Vale.Transformers.PeepHole.lemma_update_to_valid_destination_keeps_it_as_valid_src",
"Vale.X64.CPU_Features_s.movbe_enabled",
"Prims.bool",
"Vale.Def.Words_s.nat64",
"Vale.Def.Types_s.reverse_bytes_nat64",
"Vale.X64.Machine_Semantics_s.Mkmachine_state",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_regs",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_flags",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_heap",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stack",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_stackTaint",
"Vale.X64.Machine_Semantics_s.__proj__Mkmachine_state__item__ms_trace",
"Vale.X64.Machine_Semantics_s.machine_eval_ins",
"Vale.X64.InsLemmas.make_instr_t",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.InsLemmas.make_instr",
"Prims.Cons",
"Vale.X64.Instruction_s.inOut",
"Vale.X64.Instruction_s.op64",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Bswap64",
"Vale.X64.InsLemmas.make_instr_t_args",
"Vale.X64.Instruction_s.out",
"Vale.X64.Instructions_s.ins_Mov64",
"Vale.X64.InsLemmas.make_instr_annotate",
"Vale.X64.Instructions_s.ins_MovBe64",
"Vale.X64.Machine_Semantics_s.AnnotateMovbe64",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Vale.X64.Machine_s.uu___is_OReg",
"Vale.X64.Machine_s.nat64",
"Vale.X64.Machine_s.reg_64",
"Prims.squash",
"Prims.l_imp",
"Vale.Transformers.InstructionReorder.equiv_states",
"FStar.Pervasives.pattern"
] | [] | module Vale.Transformers.MovbeElim
open Vale.X64.Bytes_Code_s
open Vale.X64.Instruction_s
open Vale.X64.Instructions_s
open Vale.X64.Machine_Semantics_s
open Vale.X64.Machine_s
open Vale.X64.Print_s
open Vale.Transformers.InstructionReorder
open Vale.X64.InsLemmas
open Vale.Transformers.PeepHole
let movbe_elim_ph = {
ph = (function
| [Instr i oprs (AnnotateMovbe64 proof_of_movbe)] ->
let oprs:normal (instr_operands_t [out op64] [op64]) =
coerce_to_normal #(instr_operands_t [out op64] [op64]) oprs in
let (dst, (src, ())) = oprs in
if OReg? dst then (
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
Some [mov; bswap]
) else None
| _ -> None);
input_hint = 1;
}
module T = Vale.Def.Types_s
module H = Vale.Arch.Heap
#push-options "--initial_fuel 2 --max_fuel 2 --initial_ifuel 0 --max_ifuel 0"
let lemma_movbe_is_mov_bswap (dst src:operand64) (s:machine_state) :
Lemma
(requires (OReg? dst))
(ensures (
let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in | false | false | Vale.Transformers.MovbeElim.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 2,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_movbe_is_mov_bswap (dst src: operand64) (s: machine_state)
: Lemma (requires (OReg? dst))
(ensures
(let movbe = make_instr_annotate ins_MovBe64 (AnnotateMovbe64 ()) dst src in
let mov = make_instr ins_Mov64 dst src in
let bswap = make_instr ins_Bswap64 dst in
let s1 = machine_eval_ins movbe s in
let s2 = machine_eval_ins bswap (machine_eval_ins mov s) in
s1.ms_ok ==> equiv_states s1 s2)) | [] | Vale.Transformers.MovbeElim.lemma_movbe_is_mov_bswap | {
"file_name": "vale/code/lib/transformers/Vale.Transformers.MovbeElim.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
dst: Vale.X64.Machine_s.operand64 ->
src: Vale.X64.Machine_s.operand64 ->
s: Vale.X64.Machine_Semantics_s.machine_state
-> FStar.Pervasives.Lemma (requires OReg? dst)
(ensures
(let movbe =
Vale.X64.InsLemmas.make_instr_annotate Vale.X64.Instructions_s.ins_MovBe64
(Vale.X64.Machine_Semantics_s.AnnotateMovbe64 ())
dst
src
in
let mov = Vale.X64.InsLemmas.make_instr Vale.X64.Instructions_s.ins_Mov64 dst src in
let bswap = Vale.X64.InsLemmas.make_instr Vale.X64.Instructions_s.ins_Bswap64 dst in
let s1 = Vale.X64.Machine_Semantics_s.machine_eval_ins movbe s in
let s2 =
Vale.X64.Machine_Semantics_s.machine_eval_ins bswap
(Vale.X64.Machine_Semantics_s.machine_eval_ins mov s)
in
Mkmachine_state?.ms_ok s1 ==> Vale.Transformers.InstructionReorder.equiv_states s1 s2)) | {
"end_col": 3,
"end_line": 70,
"start_col": 43,
"start_line": 42
} |
Prims.Tot | val hash_is_supported (a: Hash.hash_alg) : Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false | val hash_is_supported (a: Hash.hash_alg) : Tot bool
let hash_is_supported (a: Hash.hash_alg) : Tot bool = | false | null | false | match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.bool"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2 | false | true | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val hash_is_supported (a: Hash.hash_alg) : Tot bool | [] | Spec.RSAPSS.hash_is_supported | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Spec.Hash.Definitions.hash_alg -> Prims.bool | {
"end_col": 14,
"end_line": 36,
"start_col": 2,
"start_line": 32
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4) | let mgf_hash_a (len: size_nat{len + 4 <= max_size_t}) (n: pos) (i: nat{i <= n}) = | false | null | false | lbytes (len + 4) | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Prims.pos",
"Prims.nat",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mgf_hash_a : len: Lib.IntTypes.size_nat{len + 4 <= Lib.IntTypes.max_size_t} ->
n: Prims.pos ->
i: Prims.nat{i <= n}
-> Type0 | [] | Spec.RSAPSS.mgf_hash_a | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
len: Lib.IntTypes.size_nat{len + 4 <= Lib.IntTypes.max_size_t} ->
n: Prims.pos ->
i: Prims.nat{i <= n}
-> Type0 | {
"end_col": 95,
"end_line": 52,
"start_col": 79,
"start_line": 52
} |
|
Prims.Tot | val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let blocks x m = (x - 1) / m + 1 | val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = | false | null | false | (x - 1) / m + 1 | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_pos",
"Prims.op_Addition",
"Prims.op_Division",
"Prims.op_Subtraction",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Mul.op_Star"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
/// | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r}) | [] | Spec.RSAPSS.blocks | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Lib.IntTypes.size_pos -> m: Lib.IntTypes.size_pos -> r: Lib.IntTypes.size_pos{x <= m * r} | {
"end_col": 32,
"end_line": 26,
"start_col": 17,
"start_line": 26
} |
Prims.Tot | val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2 | val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = | false | null | false | map2 (fun x y -> x ^. y) b1 b2 | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_pos",
"Lib.ByteSequence.lbytes",
"Lib.Sequence.map2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Hat_Dot"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1 | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len) | [] | Spec.RSAPSS.xor_bytes | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b1: Lib.ByteSequence.lbytes len -> b2: Lib.ByteSequence.lbytes len -> Lib.ByteSequence.lbytes len | {
"end_col": 57,
"end_line": 29,
"start_col": 27,
"start_line": 29
} |
Prims.Tot | val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)}) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let os2ip #len b = nat_from_bytes_be b | val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = | false | null | false | nat_from_bytes_be b | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)}) | [] | Spec.RSAPSS.os2ip | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Lib.ByteSequence.lbytes len -> res: Prims.nat{res < Prims.pow2 (8 * len)} | {
"end_col": 38,
"end_line": 73,
"start_col": 19,
"start_line": 73
} |
Prims.Tot | val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_verify a modBits pkey sLen k sgnt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then
rsapss_verify_ a modBits pkey sLen sgnt msgLen msg
else
false | val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify a modBits pkey sLen k sgnt msgLen msg = | false | null | false | let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8)
`Hash.less_than_max_input_length`
a &&
msgLen
`Hash.less_than_max_input_length`
a &&
k = blocks modBits 8
in
if b then rsapss_verify_ a modBits pkey sLen sgnt msgLen msg else false | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Spec.RSAPSS.rsapss_pkey",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.RSAPSS.rsapss_verify_",
"Prims.bool",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Prims.op_Equality",
"Prims.int",
"Prims.l_or",
"Prims.l_and",
"Prims.op_GreaterThanOrEqual",
"Prims.op_GreaterThan",
"FStar.Mul.op_Star",
"Spec.RSAPSS.blocks"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false
val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | [] | Spec.RSAPSS.rsapss_verify | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
pkey: Spec.RSAPSS.rsapss_pkey modBits ->
sLen: Lib.IntTypes.size_nat ->
k: Lib.IntTypes.size_nat ->
sgnt: Lib.ByteSequence.lbytes k ->
msgLen: Prims.nat ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> Prims.bool | {
"end_col": 9,
"end_line": 359,
"start_col": 57,
"start_line": 349
} |
Prims.Tot | val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let i2osp len n = nat_to_intseq_be len n | val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = | false | null | false | nat_to_intseq_be len n | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Lib.ByteSequence.nat_to_intseq_be",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len) | [] | Spec.RSAPSS.i2osp | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | len: Lib.IntTypes.size_nat -> n: Prims.nat{n < Prims.pow2 (8 * len)} -> Lib.ByteSequence.lbytes len | {
"end_col": 40,
"end_line": 76,
"start_col": 18,
"start_line": 76
} |
Prims.Tot | val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None | val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg = | false | null | false | let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8)
`Hash.less_than_max_input_length`
a &&
msgLen
`Hash.less_than_max_input_length`
a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8
in
if b
then
let eq_m, sgnt = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None
else None | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Spec.RSAPSS.rsapss_skey",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.bool",
"Spec.RSAPSS.blocks",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.RSAPSS.rsapss_sign_",
"Prims.op_AmpAmp",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Prims.op_Subtraction"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | [] | Spec.RSAPSS.rsapss_sign | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
skey: Spec.RSAPSS.rsapss_skey modBits ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.ByteSequence.lbytes sLen ->
msgLen: Prims.nat ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks modBits 8)) | {
"end_col": 8,
"end_line": 304,
"start_col": 53,
"start_line": 293
} |
Prims.Tot | val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_load_pkey modBits eBits nb eb =
let n = os2ip #(blocks modBits 8) nb in
let e = os2ip #(blocks eBits 8) eb in
//`n % 2 = 1` is needed to store `r2 = r * r % n` as a part of pkey
if (n % 2 = 1 && pow2 (modBits - 1) < n && n < pow2 modBits &&
0 < e && e < pow2 eBits) then
Some (Mk_rsapss_pkey n e)
else
None | val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits)
let rsapss_load_pkey modBits eBits nb eb = | false | null | false | let n = os2ip #(blocks modBits 8) nb in
let e = os2ip #(blocks eBits 8) eb in
if (n % 2 = 1 && pow2 (modBits - 1) < n && n < pow2 modBits && 0 < e && e < pow2 eBits)
then Some (Mk_rsapss_pkey n e)
else None | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.RSAPSS.modBits_t",
"Lib.IntTypes.size_pos",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.RSAPSS.blocks",
"Prims.op_AmpAmp",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.Some",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.Mk_rsapss_pkey",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.b2t",
"Prims.op_Multiply",
"Spec.RSAPSS.os2ip"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false
val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify a modBits pkey sLen k sgnt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then
rsapss_verify_ a modBits pkey sLen sgnt msgLen msg
else
false
val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits) | [] | Spec.RSAPSS.rsapss_load_pkey | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
modBits: Spec.RSAPSS.modBits_t ->
eBits: Lib.IntTypes.size_pos ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks eBits 8)
-> FStar.Pervasives.Native.option (Spec.RSAPSS.rsapss_pkey modBits) | {
"end_col": 8,
"end_line": 378,
"start_col": 42,
"start_line": 369
} |
Prims.Tot | val rsapss_pkey_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_pkey_verify a modBits eBits nb eb sLen k sgnt msgLen msg =
let pkey = rsapss_load_pkey modBits eBits nb eb in
match pkey with
| Some vpkey -> rsapss_verify a modBits vpkey sLen k sgnt msgLen msg
| None -> false | val rsapss_pkey_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_pkey_verify a modBits eBits nb eb sLen k sgnt msgLen msg = | false | null | false | let pkey = rsapss_load_pkey modBits eBits nb eb in
match pkey with
| Some vpkey -> rsapss_verify a modBits vpkey sLen k sgnt msgLen msg
| None -> false | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Lib.IntTypes.size_pos",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.RSAPSS.blocks",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.rsapss_verify",
"Prims.bool",
"FStar.Pervasives.Native.option",
"Spec.RSAPSS.rsapss_load_pkey"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false
val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify a modBits pkey sLen k sgnt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then
rsapss_verify_ a modBits pkey sLen sgnt msgLen msg
else
false
val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits)
let rsapss_load_pkey modBits eBits nb eb =
let n = os2ip #(blocks modBits 8) nb in
let e = os2ip #(blocks eBits 8) eb in
//`n % 2 = 1` is needed to store `r2 = r * r % n` as a part of pkey
if (n % 2 = 1 && pow2 (modBits - 1) < n && n < pow2 modBits &&
0 < e && e < pow2 eBits) then
Some (Mk_rsapss_pkey n e)
else
None
val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits)
let rsapss_load_skey modBits eBits dBits nb eb db =
let pkey = rsapss_load_pkey modBits eBits nb eb in
let d = os2ip #(blocks dBits 8) db in
if (Some? pkey && 0 < d && d < pow2 dBits) then
Some (Mk_rsapss_skey (Some?.v pkey) d)
else
None
val rsapss_skey_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg =
let skey = rsapss_load_skey modBits eBits dBits nb eb db in
match skey with
| Some vskey -> rsapss_sign a modBits vskey sLen salt msgLen msg
| None -> None
val rsapss_pkey_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_pkey_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool | [] | Spec.RSAPSS.rsapss_pkey_verify | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
eBits: Lib.IntTypes.size_pos ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks eBits 8) ->
sLen: Lib.IntTypes.size_nat ->
k: Lib.IntTypes.size_nat ->
sgnt: Lib.ByteSequence.lbytes k ->
msgLen: Prims.nat ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> Prims.bool | {
"end_col": 17,
"end_line": 438,
"start_col": 69,
"start_line": 434
} |
Prims.Tot | val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_load_skey modBits eBits dBits nb eb db =
let pkey = rsapss_load_pkey modBits eBits nb eb in
let d = os2ip #(blocks dBits 8) db in
if (Some? pkey && 0 < d && d < pow2 dBits) then
Some (Mk_rsapss_skey (Some?.v pkey) d)
else
None | val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits)
let rsapss_load_skey modBits eBits dBits nb eb db = | false | null | false | let pkey = rsapss_load_pkey modBits eBits nb eb in
let d = os2ip #(blocks dBits 8) db in
if (Some? pkey && 0 < d && d < pow2 dBits) then Some (Mk_rsapss_skey (Some?.v pkey) d) else None | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.RSAPSS.modBits_t",
"Lib.IntTypes.size_pos",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.RSAPSS.blocks",
"Prims.op_AmpAmp",
"FStar.Pervasives.Native.uu___is_Some",
"Spec.RSAPSS.rsapss_pkey",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Pervasives.Native.Some",
"Spec.RSAPSS.rsapss_skey",
"Spec.RSAPSS.Mk_rsapss_skey",
"FStar.Pervasives.Native.__proj__Some__item__v",
"Prims.bool",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Prims.nat",
"Prims.b2t",
"Prims.op_Multiply",
"Spec.RSAPSS.os2ip",
"Spec.RSAPSS.rsapss_load_pkey"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false
val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify a modBits pkey sLen k sgnt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then
rsapss_verify_ a modBits pkey sLen sgnt msgLen msg
else
false
val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits)
let rsapss_load_pkey modBits eBits nb eb =
let n = os2ip #(blocks modBits 8) nb in
let e = os2ip #(blocks eBits 8) eb in
//`n % 2 = 1` is needed to store `r2 = r * r % n` as a part of pkey
if (n % 2 = 1 && pow2 (modBits - 1) < n && n < pow2 modBits &&
0 < e && e < pow2 eBits) then
Some (Mk_rsapss_pkey n e)
else
None
val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits) | [] | Spec.RSAPSS.rsapss_load_skey | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
modBits: Spec.RSAPSS.modBits_t ->
eBits: Lib.IntTypes.size_pos ->
dBits: Lib.IntTypes.size_pos ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks dBits 8)
-> FStar.Pervasives.Native.option (Spec.RSAPSS.rsapss_skey modBits) | {
"end_col": 8,
"end_line": 397,
"start_col": 51,
"start_line": 390
} |
Prims.Tot | val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block | val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter = | false | null | false | let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.Mktuple2",
"Spec.Hash.Definitions.hash_length",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.Hash.Definitions.hash_length'",
"Spec.Agile.Hash.hash",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Lib.IntTypes.uint_t",
"Lib.Sequence.seq",
"Lib.Sequence.length",
"Prims.pow2",
"Prims.op_Multiply",
"Lib.ByteSequence.nat_from_intseq_be",
"Lib.ByteSequence.nat_to_intseq_be",
"FStar.Pervasives.Native.tuple2"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a) | [] | Spec.RSAPSS.mgf_hash_f | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
len:
Lib.IntTypes.size_nat
{ len + 4 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (len + 4) a } ->
i: Lib.IntTypes.size_nat ->
mgfseed_counter: Lib.ByteSequence.lbytes (len + 4)
-> Lib.ByteSequence.lbytes (len + 4) *
Lib.ByteSequence.lbytes (Spec.Hash.Definitions.hash_length a) | {
"end_col": 24,
"end_line": 50,
"start_col": 40,
"start_line": 46
} |
Prims.Tot | val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end | val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em = | false | null | false | let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[ 0 ] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[ emLen - 1 ] in
if (emLen < sLen + Hash.hash_length a + 2)
then false
else
if
not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_pos",
"Lib.ByteSequence.lbytes",
"Spec.RSAPSS.blocks",
"Prims.op_LessThan",
"Prims.bool",
"Prims.op_Negation",
"Prims.op_AmpAmp",
"FStar.UInt8.op_Equals_Hat",
"Lib.RawIntTypes.u8_to_UInt8",
"FStar.UInt8.__uint_to_t",
"Spec.RSAPSS.pss_verify_",
"Lib.IntTypes.int_t",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Prims.op_Subtraction",
"Lib.Sequence.op_String_Access",
"Prims.op_GreaterThan",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.u8",
"Lib.IntTypes.size",
"Lib.IntTypes.uint8",
"Prims.int",
"Prims.op_Modulus",
"Prims.pos",
"Prims.pow2",
"Prims.op_Multiply"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool | [] | Spec.RSAPSS.pss_verify | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
sLen:
Lib.IntTypes.size_nat
{ sLen + Spec.Hash.Definitions.hash_length a + 8 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (sLen +
Spec.Hash.Definitions.hash_length a +
8)
a } ->
msgLen: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length msgLen a} ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen} ->
emBits: Lib.IntTypes.size_pos ->
em: Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks emBits 8)
-> Prims.bool | {
"end_col": 52,
"end_line": 212,
"start_col": 44,
"start_line": 200
} |
Prims.Pure | val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0]))) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db | val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits = | false | null | false | let msBits = emBits % 8 in
if msBits > 0
then
let r = db.[ 0 ] <- db.[ 0 ] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[ 0 ] (u8 0xff >>. size (8 - msBits)) msBits;
r
else db | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [] | [
"Lib.IntTypes.size_pos",
"Lib.ByteSequence.lbytes",
"Lib.IntTypes.size_nat",
"Prims.op_GreaterThan",
"Prims.unit",
"Lib.IntTypes.logand_mask",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.u8",
"Lib.IntTypes.size",
"Prims.op_Subtraction",
"FStar.Math.Lemmas.pow2_plus",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.logand",
"Lib.Sequence.index",
"Lib.IntTypes.shift_right",
"Lib.IntTypes.mk_int",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Prims.l_Forall",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.op_Amp_Dot",
"Prims.bool",
"Prims.int",
"Prims.op_Modulus"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0]))) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0]))) | [] | Spec.RSAPSS.db_zero | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | db: Lib.ByteSequence.lbytes len -> emBits: Lib.IntTypes.size_nat
-> Prims.Pure (Lib.ByteSequence.lbytes len) | {
"end_col": 9,
"end_line": 104,
"start_col": 28,
"start_line": 97
} |
Prims.Tot | val rsapss_skey_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg =
let skey = rsapss_load_skey modBits eBits dBits nb eb db in
match skey with
| Some vskey -> rsapss_sign a modBits vskey sLen salt msgLen msg
| None -> None | val rsapss_skey_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_skey_sign a modBits eBits dBits nb eb db sLen salt msgLen msg = | false | null | false | let skey = rsapss_load_skey modBits eBits dBits nb eb db in
match skey with
| Some vskey -> rsapss_sign a modBits vskey sLen salt msgLen msg
| None -> None | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Lib.IntTypes.size_pos",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint8",
"Spec.RSAPSS.blocks",
"Lib.IntTypes.size_nat",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.RSAPSS.rsapss_skey",
"Spec.RSAPSS.rsapss_sign",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option",
"Spec.RSAPSS.rsapss_load_skey"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false
val rsapss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat
-> k:size_nat
-> sgnt:lbytes k
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify a modBits pkey sLen k sgnt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
k = blocks modBits 8 in
if b then
rsapss_verify_ a modBits pkey sLen sgnt msgLen msg
else
false
val rsapss_load_pkey:
modBits:modBits_t
-> eBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8) ->
option (rsapss_pkey modBits)
let rsapss_load_pkey modBits eBits nb eb =
let n = os2ip #(blocks modBits 8) nb in
let e = os2ip #(blocks eBits 8) eb in
//`n % 2 = 1` is needed to store `r2 = r * r % n` as a part of pkey
if (n % 2 = 1 && pow2 (modBits - 1) < n && n < pow2 modBits &&
0 < e && e < pow2 eBits) then
Some (Mk_rsapss_pkey n e)
else
None
val rsapss_load_skey:
modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8) ->
option (rsapss_skey modBits)
let rsapss_load_skey modBits eBits dBits nb eb db =
let pkey = rsapss_load_pkey modBits eBits nb eb in
let d = os2ip #(blocks dBits 8) db in
if (Some? pkey && 0 < d && d < pow2 dBits) then
Some (Mk_rsapss_skey (Some?.v pkey) d)
else
None
val rsapss_skey_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_skey_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> eBits:size_pos
-> dBits:size_pos
-> nb:lseq uint8 (blocks modBits 8)
-> eb:lseq uint8 (blocks eBits 8)
-> db:lseq uint8 (blocks dBits 8)
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8)) | [] | Spec.RSAPSS.rsapss_skey_sign | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
eBits: Lib.IntTypes.size_pos ->
dBits: Lib.IntTypes.size_pos ->
nb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks modBits 8) ->
eb: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks eBits 8) ->
db: Lib.Sequence.lseq Lib.IntTypes.uint8 (Spec.RSAPSS.blocks dBits 8) ->
sLen: Lib.IntTypes.size_nat ->
salt: Lib.ByteSequence.lbytes sLen ->
msgLen: Prims.nat ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> FStar.Pervasives.Native.option (Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks modBits 8)) | {
"end_col": 16,
"end_line": 418,
"start_col": 74,
"start_line": 414
} |
Prims.Tot | val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8)) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s) | val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg = | false | null | false | let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s) | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Spec.RSAPSS.rsapss_skey",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Spec.RSAPSS.blocks",
"Prims.op_Subtraction",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.Pervasives.Native.Mktuple2",
"Prims.bool",
"Spec.RSAPSS.i2osp",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.op_Multiply",
"FStar.Mul.op_Star",
"Prims.op_Equality",
"Prims.l_or",
"Lib.NatMod.nat_mod",
"Lib.NatMod.pow_mod",
"Prims.unit",
"Spec.RSAPSS.os2ip_lemma",
"Spec.RSAPSS.os2ip",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.RSAPSS.pss_encode",
"Prims.pos",
"Prims.int",
"FStar.Math.Lemmas.pow2_le_compat",
"Spec.RSAPSS.__proj__Mk_rsapss_skey__item__d",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__e",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__n",
"Spec.RSAPSS.rsapss_pkey",
"Spec.RSAPSS.__proj__Mk_rsapss_skey__item__pkey",
"FStar.Pervasives.Native.tuple2"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8)) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8)) | [] | Spec.RSAPSS.rsapss_sign_ | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
skey: Spec.RSAPSS.rsapss_skey modBits ->
sLen:
Lib.IntTypes.size_nat
{ sLen + Spec.Hash.Definitions.hash_length a + 8 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (sLen +
Spec.Hash.Definitions.hash_length a +
8)
a /\
sLen + Spec.Hash.Definitions.hash_length a + 2 <= Spec.RSAPSS.blocks (modBits - 1) 8 } ->
salt: Lib.ByteSequence.lbytes sLen ->
msgLen: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length msgLen a} ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> Prims.bool * Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks modBits 8) | {
"end_col": 19,
"end_line": 280,
"start_col": 54,
"start_line": 261
} |
Prims.Tot | val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg =
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n then begin
let m = pow_mod #n s e in
if m < pow2 (emLen * 8) then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false end
else false | val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool
let rsapss_verify_ a modBits pkey sLen sgnt msgLen msg = | false | null | false | let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let s = os2ip #k sgnt in
if s < n
then
let m = pow_mod #n s e in
if m < pow2 (emLen * 8)
then
let em = i2osp emLen m in
pss_verify a sLen msgLen msg emBits em
else false
else false | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Spec.RSAPSS.modBits_t",
"Spec.RSAPSS.rsapss_pkey",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Lib.ByteSequence.lbytes",
"Spec.RSAPSS.blocks",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_LessThan",
"Prims.pow2",
"FStar.Mul.op_Star",
"Spec.RSAPSS.pss_verify",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.RSAPSS.i2osp",
"Prims.bool",
"Lib.NatMod.nat_mod",
"Lib.NatMod.pow_mod",
"Prims.op_Multiply",
"Spec.RSAPSS.os2ip",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.int",
"Prims.unit",
"FStar.Math.Lemmas.pow2_le_compat",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__e",
"Spec.RSAPSS.__proj__Mk_rsapss_pkey__item__n"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end
val rsapss_sign_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a /\
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
tuple2 bool (lbytes (blocks modBits 8))
let rsapss_sign_ a modBits skey sLen salt msgLen msg =
let pkey = Mk_rsapss_skey?.pkey skey in
let n = Mk_rsapss_pkey?.n pkey in
let e = Mk_rsapss_pkey?.e pkey in
let d = Mk_rsapss_skey?.d skey in
let k = blocks modBits 8 in
FStar.Math.Lemmas.pow2_le_compat (8 * k) modBits;
let emBits = modBits - 1 in
let emLen = blocks emBits 8 in
let em = pss_encode a sLen salt msgLen msg emBits in
let m = os2ip #emLen em in
os2ip_lemma emBits em;
let s = pow_mod #n m d in
let m' = pow_mod #n s e in
let eq_m = m = m' in
let s = if eq_m then s else 0 in
(eq_m, i2osp k s)
val rsapss_sign:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> skey:rsapss_skey modBits
-> sLen:size_nat
-> salt:lbytes sLen
-> msgLen:nat
-> msg:bytes{length msg == msgLen} ->
option (lbytes (blocks modBits 8))
let rsapss_sign a modBits skey sLen salt msgLen msg =
let b =
sLen + Hash.hash_length a + 8 <= max_size_t &&
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a &&
msgLen `Hash.less_than_max_input_length` a &&
sLen + Hash.hash_length a + 2 <= blocks (modBits - 1) 8 in
if b then begin
let (eq_m, sgnt) = rsapss_sign_ a modBits skey sLen salt msgLen msg in
if eq_m then Some sgnt else None end
else
None
val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rsapss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> modBits:modBits_t
-> pkey:rsapss_pkey modBits
-> sLen:size_nat{
sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> sgnt:lbytes (blocks modBits 8)
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen} ->
Tot bool | [] | Spec.RSAPSS.rsapss_verify_ | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
modBits: Spec.RSAPSS.modBits_t ->
pkey: Spec.RSAPSS.rsapss_pkey modBits ->
sLen:
Lib.IntTypes.size_nat
{ sLen + Spec.Hash.Definitions.hash_length a + 8 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (sLen +
Spec.Hash.Definitions.hash_length a +
8)
a } ->
sgnt: Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks modBits 8) ->
msgLen: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length msgLen a} ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen}
-> Prims.bool | {
"end_col": 12,
"end_line": 335,
"start_col": 56,
"start_line": 319
} |
Prims.Tot | val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen | val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen = | false | null | false | let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc =
generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter
in
sub #uint8 #(n * hLen) acc 0 maskLen | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Lib.ByteSequence.lbytes",
"Lib.IntTypes.size_pos",
"Prims.op_LessThan",
"FStar.Mul.op_Star",
"Spec.RSAPSS.blocks",
"Spec.Hash.Definitions.hash_length",
"Prims.pow2",
"Spec.RSAPSS.mgf_hash_a",
"Lib.Sequence.seq",
"Lib.IntTypes.uint8",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"Lib.Sequence.sub",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.op_Multiply",
"Lib.Sequence.generate_blocks",
"Spec.RSAPSS.mgf_hash_f",
"Prims.pos",
"Prims.op_Subtraction",
"Prims.nat",
"Prims.op_GreaterThan",
"Lib.Sequence.lseq",
"Prims.l_Forall",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Lib.IntTypes.uint_t",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen) | [] | Spec.RSAPSS.mgf_hash | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
len:
Lib.IntTypes.size_nat
{ len + 4 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (len + 4) a } ->
mgfseed: Lib.ByteSequence.lbytes len ->
maskLen:
Lib.IntTypes.size_pos
{ Spec.RSAPSS.blocks maskLen (Spec.Hash.Definitions.hash_length a) *
Spec.Hash.Definitions.hash_length a <
Prims.pow2 32 }
-> Lib.ByteSequence.lbytes maskLen | {
"end_col": 38,
"end_line": 68,
"start_col": 36,
"start_line": 61
} |
FStar.Pervasives.Lemma | val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let os2ip_lemma emBits em =
let emLen = blocks emBits 8 in
let aux (emBits:size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8) in
if emBits % 8 > 0 then begin
nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em == nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[0]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0]);
calc (<=) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[0];
(==) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[0]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[0]);
(<=) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1)) (v em.[0] + 1) (pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
(==) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
(<=) { aux emBits; Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits) end
else begin
assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen) end | val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits)
let os2ip_lemma emBits em = | false | null | true | let emLen = blocks emBits 8 in
let aux (emBits: size_pos{emBits % 8 > 0}) : Lemma (8 * ((emBits - 1) / 8) + emBits % 8 <= emBits) =
assert ((emBits - 1) / 8 <= emBits / 8)
in
if emBits % 8 > 0
then
(nat_from_intseq_be_slice_lemma em 1;
nat_from_intseq_be_lemma0 (slice em 0 1);
assert (nat_from_bytes_be em ==
nat_from_bytes_be (slice em 1 emLen) + pow2 ((emLen - 1) * 8) * v em.[ 0 ]);
assert (nat_from_bytes_be em < pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[ 0 ]);
calc ( <= ) {
pow2 ((emLen - 1) * 8) + pow2 ((emLen - 1) * 8) * v em.[ 0 ];
( == ) { Math.Lemmas.distributivity_add_right (pow2 (8 * (emLen - 1))) 1 (v em.[ 0 ]) }
pow2 (8 * (emLen - 1)) * (1 + v em.[ 0 ]);
( <= ) { Math.Lemmas.lemma_mult_le_left (pow2 (8 * emLen - 1))
(v em.[ 0 ] + 1)
(pow2 (emBits % 8)) }
pow2 (8 * (emLen - 1)) * pow2 (emBits % 8);
( == ) { Math.Lemmas.pow2_plus (8 * (emLen - 1)) (emBits % 8) }
pow2 (8 * ((emBits - 1) / 8) + emBits % 8);
( <= ) { (aux emBits;
Math.Lemmas.pow2_le_compat emBits ((emBits - 1) - (emBits - 1) % 8 + emBits % 8)) }
pow2 emBits;
};
assert (nat_from_bytes_be em < pow2 emBits))
else
(assert (nat_from_bytes_be em < pow2 (emLen * 8));
assert (emBits == 8 * emLen)) | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.size_pos",
"Lib.ByteSequence.lbytes",
"Spec.RSAPSS.blocks",
"Prims.op_GreaterThan",
"Prims.op_Modulus",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.ByteSequence.nat_from_bytes_be",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"FStar.Calc.calc_finish",
"Prims.int",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.op_Subtraction",
"Lib.IntTypes.v",
"Lib.IntTypes.U8",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint_t",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.eq2",
"Prims.Nil",
"FStar.Calc.calc_step",
"Prims.op_Division",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.distributivity_add_right",
"Prims.squash",
"FStar.Math.Lemmas.lemma_mult_le_left",
"FStar.Math.Lemmas.pow2_plus",
"FStar.Math.Lemmas.pow2_le_compat",
"Lib.Sequence.slice",
"Lib.ByteSequence.nat_from_intseq_be_lemma0",
"Lib.ByteSequence.nat_from_intseq_be_slice_lemma",
"Prims.bool",
"Prims.pos",
"Prims.l_True",
"Prims.op_Multiply",
"FStar.Pervasives.pattern"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end
val pss_verify:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify a sLen msgLen msg emBits em =
let emLen = blocks emBits 8 in
let msBits = emBits % 8 in
let em_0 = if msBits > 0 then em.[0] &. (u8 0xff <<. size msBits) else u8 0 in
let em_last = em.[emLen - 1] in
if (emLen < sLen + Hash.hash_length a + 2) then false
else begin
if not (FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_last =^ 0xbcuy) &&
FStar.UInt8.(Lib.RawIntTypes.u8_to_UInt8 em_0 =^ 0uy))
then false
else pss_verify_ a sLen msgLen msg emBits em end
val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val os2ip_lemma: emBits:size_pos -> em:lbytes (blocks emBits 8) -> Lemma
(requires (if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8))
(ensures os2ip #(blocks emBits 8) em < pow2 emBits) | [] | Spec.RSAPSS.os2ip_lemma | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | emBits: Lib.IntTypes.size_pos -> em: Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks emBits 8)
-> FStar.Pervasives.Lemma
(requires
((match emBits % 8 > 0 with
| true -> Lib.IntTypes.v em.[ 0 ] < Prims.pow2 (emBits % 8)
| _ -> Lib.IntTypes.v em.[ 0 ] < Prims.pow2 8)
<:
Type0)) (ensures Spec.RSAPSS.os2ip em < Prims.pow2 emBits) | {
"end_col": 36,
"end_line": 245,
"start_col": 27,
"start_line": 219
} |
Prims.Tot | val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pss_verify_ a sLen msgLen msg emBits em =
let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[padLen - 1] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2) then false
else begin
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash
end | val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool
let pss_verify_ a sLen msgLen msg emBits em = | false | null | false | let hLen = Hash.hash_length a in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let maskedDB = sub em 0 dbLen in
let m1Hash = sub em dbLen hLen in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let db = xor_bytes dbMask maskedDB in
let db = db_zero db emBits in
let padLen = emLen - sLen - hLen - 1 in
let pad2 = create padLen (u8 0) in
let pad2 = pad2.[ padLen - 1 ] <- u8 0x01 in
let pad = sub db 0 padLen in
let salt = sub db padLen sLen in
if not (lbytes_eq pad pad2)
then false
else
let mHash = Hash.hash a msg in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash0 = Hash.hash a m1 in
lbytes_eq m1Hash0 m1Hash | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [
"total"
] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_pos",
"Spec.RSAPSS.blocks",
"Lib.ByteSequence.lbytes",
"Prims.op_Negation",
"Lib.ByteSequence.lbytes_eq",
"Prims.bool",
"Spec.Hash.Definitions.hash_length'",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.Agile.Hash.hash",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Prims.int",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.upd",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_disEquality",
"Lib.Sequence.op_String_Assignment",
"Spec.RSAPSS.db_zero",
"Spec.RSAPSS.xor_bytes",
"Spec.RSAPSS.mgf_hash",
"Prims.pos",
"Prims.op_Multiply",
"Prims.op_GreaterThan"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc
val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pss_verify_:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{sLen + Hash.hash_length a + 2 <= blocks emBits 8}
-> em:lbytes (blocks emBits 8) ->
Tot bool | [] | Spec.RSAPSS.pss_verify_ | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
sLen:
Lib.IntTypes.size_nat
{ sLen + Spec.Hash.Definitions.hash_length a + 8 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (sLen +
Spec.Hash.Definitions.hash_length a +
8)
a } ->
msgLen: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length msgLen a} ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen} ->
emBits:
Lib.IntTypes.size_pos
{sLen + Spec.Hash.Definitions.hash_length a + 2 <= Spec.RSAPSS.blocks emBits 8} ->
em: Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks emBits 8)
-> Prims.bool | {
"end_col": 5,
"end_line": 187,
"start_col": 45,
"start_line": 160
} |
Prims.Pure | val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8) | [
{
"abbrev": true,
"full_module": "Spec.Agile.Hash",
"short_module": "Hash"
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.NatMod",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pss_encode a sLen salt msgLen msg emBits =
let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
//m1 = [8 * 0x00; mHash; salt]
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
//db = [0x00;..; 0x00; 0x01; salt]
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[last_before_salt] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
//em = [maskedDB; m1Hash; 0xbc]
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[0] == v maskedDB.[0]);
em.[emLen - 1] <- u8 0xbc | val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8)
let pss_encode a sLen salt msgLen msg emBits = | false | null | false | let mHash = Hash.hash a msg in
let hLen = Hash.hash_length a in
let m1Len = 8 + hLen + sLen in
let m1 = create m1Len (u8 0) in
let m1 = update_sub m1 8 hLen mHash in
let m1 = update_sub m1 (8 + hLen) sLen salt in
let m1Hash = Hash.hash a m1 in
let emLen = blocks emBits 8 in
let dbLen = emLen - hLen - 1 in
let db = create dbLen (u8 0) in
let last_before_salt = dbLen - sLen - 1 in
let db = db.[ last_before_salt ] <- u8 1 in
let db = update_sub db (last_before_salt + 1) sLen salt in
let dbMask = mgf_hash a hLen m1Hash dbLen in
let maskedDB = xor_bytes db dbMask in
let maskedDB = db_zero maskedDB emBits in
let em = create emLen (u8 0) in
let em = update_sub em 0 dbLen maskedDB in
let em = update_sub em dbLen hLen m1Hash in
assert (v em.[ 0 ] == v maskedDB.[ 0 ]);
em.[ emLen - 1 ] <- u8 0xbc | {
"checked_file": "Spec.RSAPSS.fst.checked",
"dependencies": [
"Spec.Agile.Hash.fsti.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.RawIntTypes.fsti.checked",
"Lib.NatMod.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.UInt8.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Spec.RSAPSS.fst"
} | [] | [
"Spec.Hash.Definitions.hash_alg",
"Prims.b2t",
"Spec.RSAPSS.hash_is_supported",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Spec.Hash.Definitions.hash_length",
"Lib.IntTypes.max_size_t",
"Spec.Hash.Definitions.less_than_max_input_length",
"Lib.ByteSequence.lbytes",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_pos",
"Spec.RSAPSS.blocks",
"Lib.Sequence.op_String_Assignment",
"Prims.op_Subtraction",
"Lib.IntTypes.u8",
"Prims.unit",
"Prims._assert",
"Lib.IntTypes.range_t",
"Lib.IntTypes.v",
"Lib.Sequence.op_String_Access",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.l_or",
"Prims.op_LessThan",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Spec.RSAPSS.db_zero",
"Spec.RSAPSS.xor_bytes",
"Spec.RSAPSS.mgf_hash",
"FStar.Seq.Base.upd",
"Prims.pow2",
"Prims.op_disEquality",
"Prims.int",
"Prims.pos",
"Prims.op_Multiply",
"Spec.Hash.Definitions.hash_length'",
"Spec.Agile.Hash.hash",
"Prims.op_GreaterThan"
] | [] | module Spec.RSAPSS
open FStar.Mul
open Lib.IntTypes
open Lib.NatMod
open Lib.Sequence
open Lib.ByteSequence
open Lib.LoopCombinators
module Hash = Spec.Agile.Hash
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
(**
RFC spec of RSA-PSS: https://tools.ietf.org/html/rfc8017#section-8.1
List of supported hash functions: https://tools.ietf.org/html/rfc8446#appendix-B.3.1.3
Mask generation function: https://tools.ietf.org/html/rfc8017#page-67
*)
///
/// Auxillary functions
///
val blocks: x:size_pos -> m:size_pos -> Tot (r:size_pos{x <= m * r})
let blocks x m = (x - 1) / m + 1
val xor_bytes: #len:size_pos -> b1:lbytes len -> b2:lbytes len -> Tot (lbytes len)
let xor_bytes #len b1 b2 = map2 (fun x y -> x ^. y) b1 b2
let hash_is_supported (a:Hash.hash_alg) : Tot bool =
match a with
| Hash.SHA2_256 -> true
| Hash.SHA2_384 -> true
| Hash.SHA2_512 -> true
| _ -> false
(* Mask Generation Function *)
val mgf_hash_f:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> i:size_nat
-> mgfseed_counter:lbytes (len + 4) ->
lbytes (len + 4) & lbytes (Hash.hash_length a)
let mgf_hash_f a len i mgfseed_counter =
let counter = nat_to_intseq_be 4 i in
let mgfseed_counter = update_sub mgfseed_counter len 4 counter in
let block = Hash.hash a mgfseed_counter in
mgfseed_counter, block
let mgf_hash_a (len:size_nat{len + 4 <= max_size_t}) (n:pos) (i:nat{i <= n}) = lbytes (len + 4)
val mgf_hash:
a:Hash.hash_alg{hash_is_supported a}
-> len:size_nat{len + 4 <= max_size_t /\ (len + 4) `Hash.less_than_max_input_length` a}
-> mgfseed:lbytes len
-> maskLen:size_pos{(blocks maskLen (Hash.hash_length a)) * Hash.hash_length a < pow2 32} ->
Tot (lbytes maskLen)
let mgf_hash a len mgfseed maskLen =
let mgfseed_counter = create (len + 4) (u8 0) in
let mgfseed_counter = update_sub mgfseed_counter 0 len mgfseed in
let hLen = Hash.hash_length a in
let n = blocks maskLen hLen in
let _, acc = generate_blocks #uint8 hLen n n (mgf_hash_a len n) (mgf_hash_f a len) mgfseed_counter in
sub #uint8 #(n * hLen) acc 0 maskLen
(* Bignum convert functions *)
val os2ip: #len:size_nat -> b:lbytes len -> Tot (res:nat{res < pow2 (8 * len)})
let os2ip #len b = nat_from_bytes_be b
val i2osp: len:size_nat -> n:nat{n < pow2 (8 * len)} -> Tot (lbytes len)
let i2osp len n = nat_to_intseq_be len n
///
/// RSA
///
type modBits_t = modBits:size_nat{1 < modBits}
noeq type rsapss_pkey (modBits:modBits_t) =
| Mk_rsapss_pkey: n:pos{pow2 (modBits - 1) < n /\ n < pow2 modBits} -> e:pos -> rsapss_pkey modBits
noeq type rsapss_skey (modBits:modBits_t) =
| Mk_rsapss_skey: pkey:rsapss_pkey modBits -> d:pos -> rsapss_skey modBits
val db_zero: #len:size_pos -> db:lbytes len -> emBits:size_nat ->
Pure (lbytes len)
(requires True)
(ensures fun res ->
(v res.[0] == (if emBits % 8 > 0 then v db.[0] % pow2 (emBits % 8) else v db.[0])))
let db_zero #len db emBits =
let msBits = emBits % 8 in
if msBits > 0 then begin
let r = db.[0] <- db.[0] &. (u8 0xff >>. size (8 - msBits)) in
Math.Lemmas.pow2_plus msBits (8 - msBits);
logand_mask db.[0] (u8 0xff >>. size (8 - msBits)) msBits;
r end
else db
val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8) | false | false | Spec.RSAPSS.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val pss_encode:
a:Hash.hash_alg{hash_is_supported a}
-> sLen:size_nat{sLen + Hash.hash_length a + 8 <= max_size_t /\
(sLen + Hash.hash_length a + 8) `Hash.less_than_max_input_length` a}
-> salt:lbytes sLen
-> msgLen:nat{msgLen `Hash.less_than_max_input_length` a}
-> msg:bytes{length msg == msgLen}
-> emBits:size_pos{Hash.hash_length a + sLen + 2 <= blocks emBits 8} ->
Pure (lbytes (blocks emBits 8))
(requires True)
(ensures fun em -> if emBits % 8 > 0 then v em.[0] < pow2 (emBits % 8) else v em.[0] < pow2 8) | [] | Spec.RSAPSS.pss_encode | {
"file_name": "specs/Spec.RSAPSS.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Spec.Hash.Definitions.hash_alg{Spec.RSAPSS.hash_is_supported a} ->
sLen:
Lib.IntTypes.size_nat
{ sLen + Spec.Hash.Definitions.hash_length a + 8 <= Lib.IntTypes.max_size_t /\
Spec.Hash.Definitions.less_than_max_input_length (sLen +
Spec.Hash.Definitions.hash_length a +
8)
a } ->
salt: Lib.ByteSequence.lbytes sLen ->
msgLen: Prims.nat{Spec.Hash.Definitions.less_than_max_input_length msgLen a} ->
msg: Lib.ByteSequence.bytes{Lib.Sequence.length msg == msgLen} ->
emBits:
Lib.IntTypes.size_pos
{Spec.Hash.Definitions.hash_length a + sLen + 2 <= Spec.RSAPSS.blocks emBits 8}
-> Prims.Pure (Lib.ByteSequence.lbytes (Spec.RSAPSS.blocks emBits 8)) | {
"end_col": 27,
"end_line": 147,
"start_col": 46,
"start_line": 119
} |
FStar.Pervasives.Lemma | val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime | val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () = | false | null | true | assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.unit",
"FStar.Math.Lemmas.modulo_lemma",
"Spec.Curve25519.prime",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Modulus",
"Prims.pow2"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_prime | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _: Prims.unit -> FStar.Pervasives.Lemma (ensures Prims.pow2 255 % Spec.Curve25519.prime = 19) | {
"end_col": 41,
"end_line": 73,
"start_col": 2,
"start_line": 71
} |
FStar.Pervasives.Lemma | val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n | val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n = | false | null | true | FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (- (b / n)) n | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Prims.int",
"Prims.pos",
"FStar.Math.Lemmas.lemma_mod_plus",
"Prims.op_Subtraction",
"Prims.op_Modulus",
"Prims.op_Minus",
"Prims.op_Division",
"Prims.unit",
"FStar.Math.Lemmas.distributivity_sub_left",
"FStar.Math.Lemmas.lemma_div_mod"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mod_sub_distr | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Prims.int -> b: Prims.int -> n: Prims.pos
-> FStar.Pervasives.Lemma (ensures (a - b % n) % n = (a - b) % n) | {
"end_col": 61,
"end_line": 24,
"start_col": 2,
"start_line": 21
} |
FStar.Pervasives.Lemma | val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f' | val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' = | false | null | true | let f0, f1, f2, f3, f4 = f in
let f0', f1', f2', f3', f4' = f' in
if
((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff ||
v f1 <> 0x7ffffffffffff ||
v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f' | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"Prims.op_AmpAmp",
"Prims.op_BarBar",
"Prims.op_disEquality",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_LessThan",
"Prims.op_Equality",
"Lib.IntTypes.range_t",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_subtract_p5_0",
"Prims.bool",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_subtract_p5_1",
"Prims.unit"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff))))) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_subtract_p | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1)} ->
f': Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let _ = f' in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0' f1' f2' f3' f4' = _ in
Lib.IntTypes.v f4 <> 0x7ffffffffffff || Lib.IntTypes.v f3 <> 0x7ffffffffffff ||
Lib.IntTypes.v f2 <> 0x7ffffffffffff ||
Lib.IntTypes.v f1 <> 0x7ffffffffffff ||
Lib.IntTypes.v f0 < 0x7ffffffffffed /\
Lib.IntTypes.v f0' = Lib.IntTypes.v f0 && Lib.IntTypes.v f1' = Lib.IntTypes.v f1 &&
Lib.IntTypes.v f2' = Lib.IntTypes.v f2 &&
Lib.IntTypes.v f3' = Lib.IntTypes.v f3 &&
Lib.IntTypes.v f4' = Lib.IntTypes.v f4 \/
Lib.IntTypes.v f4 = 0x7ffffffffffff && Lib.IntTypes.v f3 = 0x7ffffffffffff &&
Lib.IntTypes.v f2 = 0x7ffffffffffff &&
Lib.IntTypes.v f1 = 0x7ffffffffffff &&
Lib.IntTypes.v f0 >= 0x7ffffffffffed /\
Lib.IntTypes.v f0' = Lib.IntTypes.v f0 - 0x7ffffffffffed &&
Lib.IntTypes.v f1' = Lib.IntTypes.v f1 - 0x7ffffffffffff &&
Lib.IntTypes.v f2' = Lib.IntTypes.v f2 - 0x7ffffffffffff &&
Lib.IntTypes.v f3' = Lib.IntTypes.v f3 - 0x7ffffffffffff &&
Lib.IntTypes.v f4' = Lib.IntTypes.v f4 - 0x7ffffffffffff)
<:
Type0)
<:
Type0))
(ensures
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f' ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f % Spec.Curve25519.prime) | {
"end_col": 31,
"end_line": 746,
"start_col": 27,
"start_line": 740
} |
FStar.Pervasives.Lemma | val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204) | val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f = | false | null | true | assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm ((pow2 51 * pow2 51) * pow2 51 = pow2 153);
assert_norm (((pow2 51 * pow2 51) * pow2 51) * pow2 51 = pow2 204) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_as_nat1 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f ==
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Prims.pow2 51 + Lib.IntTypes.v f2 * Prims.pow2 102 +
Lib.IntTypes.v f3 * Prims.pow2 153 +
Lib.IntTypes.v f4 * Prims.pow2 204)
<:
Type0)) | {
"end_col": 64,
"end_line": 813,
"start_col": 2,
"start_line": 810
} |
FStar.Pervasives.Lemma | val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime | val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' = | false | null | true | let f0, f1, f2, f3, f4 = f in
let f0', f1', f2', f3', f4' = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime ==
(v f0' + v f1' * pow51 + (v f2' * pow51) * pow51 + ((v f3' * pow51) * pow51) * pow51 +
(((v f4' * pow51) * pow51) * pow51) * pow51) %
prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 +
((v f2 - (pow2 51 - 1)) * pow2 51) * pow2 51 +
(((v f3 - (pow2 51 - 1)) * pow2 51) * pow2 51) * pow2 51 +
((((v f4 - (pow2 51 - 1)) * pow2 51) * pow2 51) * pow2 51) * pow2 51) %
prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + (v f2 * pow2 51) * pow2 51 + ((v f3 * pow2 51) * pow2 51) * pow2 51 +
(((v f4 * pow2 51) * pow2 51) * pow2 51) * pow2 51 -
prime) %
prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_sub",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Spec.Curve25519.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Prims.pow2",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.pos"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff))) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_subtract_p5_1 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1)} ->
f': Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let _ = f' in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0' f1' f2' f3' f4' = _ in
Lib.IntTypes.v f4 = 0x7ffffffffffff && Lib.IntTypes.v f3 = 0x7ffffffffffff &&
Lib.IntTypes.v f2 = 0x7ffffffffffff &&
Lib.IntTypes.v f1 = 0x7ffffffffffff &&
Lib.IntTypes.v f0 >= 0x7ffffffffffed /\
Lib.IntTypes.v f0' = Lib.IntTypes.v f0 - 0x7ffffffffffed &&
Lib.IntTypes.v f1' = Lib.IntTypes.v f1 - 0x7ffffffffffff &&
Lib.IntTypes.v f2' = Lib.IntTypes.v f2 - 0x7ffffffffffff &&
Lib.IntTypes.v f3' = Lib.IntTypes.v f3 - 0x7ffffffffffff &&
Lib.IntTypes.v f4' = Lib.IntTypes.v f4 - 0x7ffffffffffff)
<:
Type0)
<:
Type0))
(ensures
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f' ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f % Spec.Curve25519.prime) | {
"end_col": 53,
"end_line": 725,
"start_col": 30,
"start_line": 710
} |
FStar.Pervasives.Lemma | val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_cswap2_step bit p1 p2 =
let mask = u64 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 64 - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else u64 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1 | val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step bit p1 p2 = | false | null | true | let mask = u64 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 64 - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else u64 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1 | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.logxor_lemma",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Hat_Dot",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Lib.IntTypes.u64",
"Prims.l_imp",
"Lib.IntTypes.logand_lemma",
"Lib.IntTypes.op_Amp_Dot",
"Prims.op_Subtraction",
"Prims.pow2",
"Lib.IntTypes.op_Subtraction_Dot"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204)
val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem0 f =
assert_norm (pow51 = pow2 51);
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64 * pow2 64 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 64 * pow2 64 * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f
val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow51 = pow2 51);
let o0 = f0 |. (f1 <<. 51ul) in
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f1) 64 51;
logor_disjoint f0 (f1 <<. 51ul) 51;
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
FStar.Math.Lemmas.lemma_div_lt (v f1) 51 13;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 38;
FStar.Math.Lemmas.multiple_modulo_lemma (v f2 % pow2 26) (pow2 38);
logor_disjoint (f1 >>. 13ul) (f2 <<. 38ul) 38;
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 51 26;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f3) 64 25;
FStar.Math.Lemmas.multiple_modulo_lemma (v f3 % pow2 39) (pow2 25);
logor_disjoint (f2 >>. 26ul) (f3 <<. 25ul) 25;
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
FStar.Math.Lemmas.lemma_div_lt (v f3) 51 39;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 12;
FStar.Math.Lemmas.multiple_modulo_lemma (v f4 % pow2 52) (pow2 12);
logor_disjoint (f3 >>. 39ul) (f4 <<. 12ul) 12;
lemma_store_felem0 f
val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_cswap2_step | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
bit: Lib.IntTypes.uint64{Lib.IntTypes.v bit <= 1} ->
p1: Lib.IntTypes.uint64 ->
p2: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let mask = Lib.IntTypes.u64 0 -. bit in
let dummy = mask &. p1 ^. p2 in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
(match Lib.IntTypes.v bit = 1 with
| true -> p1' == p2 /\ p2' == p1
| _ -> p1' == p1 /\ p2' == p2)
<:
Type0)) | {
"end_col": 20,
"end_line": 906,
"start_col": 33,
"start_line": 894
} |
FStar.Pervasives.Lemma | val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime | val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' = | false | null | true | let f0, f1, f2, f3, f4 = f in
let f0', f1', f2', f3', f4' = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f ==
v f0 + v f1 * pow51 + (v f2 * pow51) * pow51 + ((v f3 * pow51) * pow51) * pow51 +
(((v f4 * pow51) * pow51) * pow51) * pow51);
assert (as_nat5 f <=
pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + ((pow2 51 - 1) * pow2 51) * pow2 51 +
(((pow2 51 - 1) * pow2 51) * pow2 51) * pow2 51 +
((((pow2 51 - 1) * pow2 51) * pow2 51) * pow2 51) * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.modulo_lemma",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Spec.Curve25519.prime",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.int",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.pos"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_subtract_p5_0 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1)} ->
f': Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let _ = f' in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0' f1' f2' f3' f4' = _ in
Lib.IntTypes.v f4 <> 0x7ffffffffffff || Lib.IntTypes.v f3 <> 0x7ffffffffffff ||
Lib.IntTypes.v f2 <> 0x7ffffffffffff ||
Lib.IntTypes.v f1 <> 0x7ffffffffffff ||
Lib.IntTypes.v f0 < 0x7ffffffffffed /\
Lib.IntTypes.v f0' = Lib.IntTypes.v f0 && Lib.IntTypes.v f1' = Lib.IntTypes.v f1 &&
Lib.IntTypes.v f2' = Lib.IntTypes.v f2 &&
Lib.IntTypes.v f3' = Lib.IntTypes.v f3 &&
Lib.IntTypes.v f4' = Lib.IntTypes.v f4)
<:
Type0)
<:
Type0))
(ensures
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f' ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f % Spec.Curve25519.prime) | {
"end_col": 51,
"end_line": 697,
"start_col": 30,
"start_line": 685
} |
FStar.Pervasives.Lemma | val lemma_fmul_fsqr5: f:felem5{felem_fits5 f (9, 10, 9, 9, 9)} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let s0 = v f0 * v f0 + 38 * v f4 * v f1 + 38 * v f2 * v f3 in
let s1 = 2 * v f0 * v f1 + 38 * v f4 * v f2 + 19 * v f3 * v f3 in
let s2 = 2 * v f0 * v f2 + v f1 * v f1 + 38 * v f4 * v f3 in
let s3 = 2 * v f0 * v f3 + 2 * v f1 * v f2 + 19 * v f4 * v f4 in
let s4 = 2 * v f0 * v f4 + 2 * v f1 * v f3 + v f2 * v f2 in
fmul (feval f) (feval f) == (s0 + s1 * pow51 + s2 * pow51 * pow51 +
s3 * pow51 * pow51 * pow51 + s4 * pow51 * pow51 * pow51 * pow51) % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul_fsqr5 f =
let (f0, f1, f2, f3, f4) = f in
lemma_fmul5 f f;
lemma_smul_felem5 f0 (f0, f1, f2, f3, f4);
lemma_smul_felem5 f1 (f4 *! u64 19, f0, f1, f2, f3);
lemma_mul_assos_3 (v f1) (v f4) 19;
lemma_smul_felem5 f2 (f3 *! u64 19, f4 *! u64 19, f0, f1, f2);
lemma_mul_assos_3 (v f2) (v f3) 19;
lemma_mul_assos_3 (v f2) (v f4) 19;
lemma_smul_felem5 f3 (f2 *! u64 19, f3 *! u64 19, f4 *! u64 19, f0, f1);
lemma_mul_assos_3 (v f3) (v f2) 19;
lemma_mul_assos_3 (v f3) (v f3) 19;
lemma_mul_assos_3 (v f3) (v f4) 19;
lemma_smul_felem5 f4 (f1 *! u64 19, f2 *! u64 19, f3 *! u64 19, f4 *! u64 19, f0);
lemma_mul_assos_3 (v f4) (v f1) 19;
lemma_mul_assos_3 (v f4) (v f2) 19;
lemma_mul_assos_3 (v f4) (v f3) 19;
lemma_mul_assos_3 (v f4) (v f4) 19;
lemma_fmul_fsqr50 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr51 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr52 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr53 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr54 (v f0) (v f1) (v f2) (v f3) (v f4) | val lemma_fmul_fsqr5: f:felem5{felem_fits5 f (9, 10, 9, 9, 9)} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let s0 = v f0 * v f0 + 38 * v f4 * v f1 + 38 * v f2 * v f3 in
let s1 = 2 * v f0 * v f1 + 38 * v f4 * v f2 + 19 * v f3 * v f3 in
let s2 = 2 * v f0 * v f2 + v f1 * v f1 + 38 * v f4 * v f3 in
let s3 = 2 * v f0 * v f3 + 2 * v f1 * v f2 + 19 * v f4 * v f4 in
let s4 = 2 * v f0 * v f4 + 2 * v f1 * v f3 + v f2 * v f2 in
fmul (feval f) (feval f) == (s0 + s1 * pow51 + s2 * pow51 * pow51 +
s3 * pow51 * pow51 * pow51 + s4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_fmul_fsqr5 f = | false | null | true | let f0, f1, f2, f3, f4 = f in
lemma_fmul5 f f;
lemma_smul_felem5 f0 (f0, f1, f2, f3, f4);
lemma_smul_felem5 f1 (f4 *! u64 19, f0, f1, f2, f3);
lemma_mul_assos_3 (v f1) (v f4) 19;
lemma_smul_felem5 f2 (f3 *! u64 19, f4 *! u64 19, f0, f1, f2);
lemma_mul_assos_3 (v f2) (v f3) 19;
lemma_mul_assos_3 (v f2) (v f4) 19;
lemma_smul_felem5 f3 (f2 *! u64 19, f3 *! u64 19, f4 *! u64 19, f0, f1);
lemma_mul_assos_3 (v f3) (v f2) 19;
lemma_mul_assos_3 (v f3) (v f3) 19;
lemma_mul_assos_3 (v f3) (v f4) 19;
lemma_smul_felem5 f4 (f1 *! u64 19, f2 *! u64 19, f3 *! u64 19, f4 *! u64 19, f0);
lemma_mul_assos_3 (v f4) (v f1) 19;
lemma_mul_assos_3 (v f4) (v f2) 19;
lemma_mul_assos_3 (v f4) (v f3) 19;
lemma_mul_assos_3 (v f4) (v f4) 19;
lemma_fmul_fsqr50 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr51 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr52 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr53 (v f0) (v f1) (v f2) (v f3) (v f4);
lemma_fmul_fsqr54 (v f0) (v f1) (v f2) (v f3) (v f4) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr54",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr53",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr52",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr50",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_3",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_smul_felem5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.u64",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204)
val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem0 f =
assert_norm (pow51 = pow2 51);
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64 * pow2 64 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 64 * pow2 64 * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f
val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow51 = pow2 51);
let o0 = f0 |. (f1 <<. 51ul) in
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f1) 64 51;
logor_disjoint f0 (f1 <<. 51ul) 51;
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
FStar.Math.Lemmas.lemma_div_lt (v f1) 51 13;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 38;
FStar.Math.Lemmas.multiple_modulo_lemma (v f2 % pow2 26) (pow2 38);
logor_disjoint (f1 >>. 13ul) (f2 <<. 38ul) 38;
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 51 26;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f3) 64 25;
FStar.Math.Lemmas.multiple_modulo_lemma (v f3 % pow2 39) (pow2 25);
logor_disjoint (f2 >>. 26ul) (f3 <<. 25ul) 25;
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
FStar.Math.Lemmas.lemma_div_lt (v f3) 51 39;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 12;
FStar.Math.Lemmas.multiple_modulo_lemma (v f4 % pow2 52) (pow2 12);
logor_disjoint (f3 >>. 39ul) (f4 <<. 12ul) 12;
lemma_store_felem0 f
val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step bit p1 p2 =
let mask = u64 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 64 - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else u64 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
#push-options "--max_fuel 0 --max_ifuel 0"
val mul64_wide_add3_lemma:
#m0:scale64 -> #m1:scale64 -> #m2:scale64
-> #m3:scale64 -> #m4:scale64 -> #m5:scale64
-> a0:uint64{felem_fits1 a0 m0}
-> a1:uint64{felem_fits1 a1 m1}
-> b0:uint64{felem_fits1 b0 m2}
-> b1:uint64{felem_fits1 b1 m3}
-> c0:uint64{felem_fits1 c0 m4}
-> c1:uint64{felem_fits1 c1 m5}
-> Lemma
(requires m0 * m1 + m2 * m3 + m4 * m5 < pow2 13)
(ensures
v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 128 /\
(v a0 * v a1 + v b0 * v b1 + v c0 * v c1) <=
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51)
let mul64_wide_add3_lemma #m0 #m1 #m2 #m3 #m4 #m5 a0 a1 b0 b1 c0 c1 =
assert (pow51 = pow2 51);
lemma_mul_le (v a0) (m0 * max51) (v a1) (m1 * max51);
lemma_mul_le (v b0) (m2 * max51) (v b1) (m3 * max51);
lemma_mul_le (v c0) (m4 * max51) (v c1) (m5 * max51);
lemma_add_le (v a0 * v a1) (m0 * max51 * m1 * max51) (v b0 * v b1) (m2 * max51 * m3 * max51);
lemma_add_le (v a0 * v a1 + v b0 * v b1) (m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51)
(v c0 * v c1) (m4 * max51 * m5 * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 <=
m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51 + m4 * max51 * m5 * max51);
assert_by_tactic (m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51 + m4 * max51 * m5 * max51 ==
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51) canon;
assert_norm (pow2 13 > 0);
lemma_mul_le (m0 * m1 + m2 * m3 + m4 * m5) (pow2 13 - 1) (max51 * max51) (max51 * max51);
assert ((m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51 < pow2 13 * max51 * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 13 * max51 * max51);
assert_norm (pow2 13 * pow2 51 * pow2 51 = pow2 115);
assert_norm (pow2 115 < pow2 128)
#pop-options
val lemma_fmul_fsqr50: f0:nat -> f1:nat -> f2:nat -> f3:nat -> f4:nat ->
Lemma
(f0 * f0 + f1 * f4 * 19 + f2 * f3 * 19 + f3 * f2 * 19 + f4 * f1 * 19 ==
f0 * f0 + 38 * f4 * f1 + 38 * f2 * f3)
let lemma_fmul_fsqr50 f0 f1 f2 f3 f4 = ()
val lemma_fmul_fsqr51: f0:nat -> f1:nat -> f2:nat -> f3:nat -> f4:nat ->
Lemma
(f0 * f1 * pow51 + f1 * f0 * pow51 + f2 * f4 * 19 * pow51 +
f3 * f3 * 19 * pow51 + f4 * f2 * 19 * pow51 ==
(2 * f0 * f1 + 38 * f4 * f2 + 19 * f3 * f3) * pow51)
let lemma_fmul_fsqr51 f0 f1 f2 f3 f4 = ()
val lemma_fmul_fsqr52: f0:nat -> f1:nat -> f2:nat -> f3:nat -> f4:nat ->
Lemma
(f0 * f2 * pow51 * pow51 + f1 * f1 * pow51 * pow51 + f2 * f0 * pow51 * pow51 +
f3 * f4 * 19 * pow51 * pow51 + f4 * f3 * 19 * pow51 * pow51 ==
(2 * f0 * f2 + f1 * f1 + 38 * f4 * f3) * pow51 * pow51)
let lemma_fmul_fsqr52 f0 f1 f2 f3 f4 = ()
val lemma_fmul_fsqr53: f0:nat -> f1:nat -> f2:nat -> f3:nat -> f4:nat ->
Lemma
(f0 * f3 * pow51 * pow51 * pow51 + f1 * f2 * pow51 * pow51 * pow51 +
f2 * f1 * pow51 * pow51 * pow51 + f3 * f0 * pow51 * pow51 * pow51 +
f4 * f4 * 19 * pow51 * pow51 * pow51 ==
(2 * f0 * f3 + 2 * f1 * f2 + 19 * f4 * f4) * pow51 * pow51 * pow51)
let lemma_fmul_fsqr53 f0 f1 f2 f3 f4 = ()
val lemma_fmul_fsqr54: f0:nat -> f1:nat -> f2:nat -> f3:nat -> f4:nat ->
Lemma
(f0 * f4 * pow51 * pow51 * pow51 * pow51 + f1 * f3 * pow51 * pow51 * pow51 * pow51 +
f2 * f2 * pow51 * pow51 * pow51 * pow51 + f3 * f1 * pow51 * pow51 * pow51 * pow51 +
f4 * f0 * pow51 * pow51 * pow51 * pow51 ==
(2 * f0 * f4 + 2 * f1 * f3 + f2 * f2) * pow51 * pow51 * pow51 * pow51)
let lemma_fmul_fsqr54 f0 f1 f2 f3 f4 = ()
val lemma_fmul_fsqr5: f:felem5{felem_fits5 f (9, 10, 9, 9, 9)} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let s0 = v f0 * v f0 + 38 * v f4 * v f1 + 38 * v f2 * v f3 in
let s1 = 2 * v f0 * v f1 + 38 * v f4 * v f2 + 19 * v f3 * v f3 in
let s2 = 2 * v f0 * v f2 + v f1 * v f1 + 38 * v f4 * v f3 in
let s3 = 2 * v f0 * v f3 + 2 * v f1 * v f2 + 19 * v f4 * v f4 in
let s4 = 2 * v f0 * v f4 + 2 * v f1 * v f3 + v f2 * v f2 in
fmul (feval f) (feval f) == (s0 + s1 * pow51 + s2 * pow51 * pow51 + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul_fsqr5: f:felem5{felem_fits5 f (9, 10, 9, 9, 9)} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let s0 = v f0 * v f0 + 38 * v f4 * v f1 + 38 * v f2 * v f3 in
let s1 = 2 * v f0 * v f1 + 38 * v f4 * v f2 + 19 * v f3 * v f3 in
let s2 = 2 * v f0 * v f2 + v f1 * v f1 + 38 * v f4 * v f3 in
let s3 = 2 * v f0 * v f3 + 2 * v f1 * v f2 + 19 * v f4 * v f4 in
let s4 = 2 * v f0 * v f4 + 2 * v f1 * v f3 + v f2 * v f2 in
fmul (feval f) (feval f) == (s0 + s1 * pow51 + s2 * pow51 * pow51 +
s3 * pow51 * pow51 * pow51 + s4 * pow51 * pow51 * pow51 * pow51) % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul_fsqr5 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let s0 =
Lib.IntTypes.v f0 * Lib.IntTypes.v f0 + (38 * Lib.IntTypes.v f4) * Lib.IntTypes.v f1 +
(38 * Lib.IntTypes.v f2) * Lib.IntTypes.v f3
in
let s1 =
(2 * Lib.IntTypes.v f0) * Lib.IntTypes.v f1 +
(38 * Lib.IntTypes.v f4) * Lib.IntTypes.v f2 +
(19 * Lib.IntTypes.v f3) * Lib.IntTypes.v f3
in
let s2 =
(2 * Lib.IntTypes.v f0) * Lib.IntTypes.v f2 + Lib.IntTypes.v f1 * Lib.IntTypes.v f1 +
(38 * Lib.IntTypes.v f4) * Lib.IntTypes.v f3
in
let s3 =
(2 * Lib.IntTypes.v f0) * Lib.IntTypes.v f3 +
(2 * Lib.IntTypes.v f1) * Lib.IntTypes.v f2 +
(19 * Lib.IntTypes.v f4) * Lib.IntTypes.v f4
in
let s4 =
(2 * Lib.IntTypes.v f0) * Lib.IntTypes.v f4 +
(2 * Lib.IntTypes.v f1) * Lib.IntTypes.v f3 +
Lib.IntTypes.v f2 * Lib.IntTypes.v f2
in
Spec.Curve25519.fmul (Hacl.Spec.Curve25519.Field51.Definition.feval f)
(Hacl.Spec.Curve25519.Field51.Definition.feval f) ==
(s0 + s1 * Hacl.Spec.Curve25519.Field51.Definition.pow51 +
(s2 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
((s3 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
(((s4 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) %
Spec.Curve25519.prime)
<:
Type0)) | {
"end_col": 54,
"end_line": 1014,
"start_col": 24,
"start_line": 991
} |
FStar.Pervasives.Lemma | val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime | val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r = | false | null | true | let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert (((pow51 * pow51) * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert (((pow51 * pow51) * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51
(as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u64",
"Spec.Curve25519.prime",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_3"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime == | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ _ r3 r4 = _ in
Lib.IntTypes.v r4 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r3 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51)
<:
Type0))
(ensures
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
(Hacl.Spec.Curve25519.Field51.Definition.pow51 *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) %
Spec.Curve25519.prime)
<:
Type0)) | {
"end_col": 104,
"end_line": 161,
"start_col": 31,
"start_line": 150
} |
FStar.Pervasives.Lemma | val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime | val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r = | false | null | true | let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = (pow51 * pow51) * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((((pow51 * pow51) * pow51) * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((((pow51 * pow51) * pow51) * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51
(as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51
(as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u64",
"Spec.Curve25519.prime",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_4"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime == | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51_pow51 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ r2 r3 r4 = _ in
Lib.IntTypes.v r4 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r3 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r2 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51)
<:
Type0))
(ensures
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
((Hacl.Spec.Curve25519.Field51.Definition.pow51 *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1) %
Spec.Curve25519.prime)
<:
Type0)) | {
"end_col": 114,
"end_line": 182,
"start_col": 37,
"start_line": 171
} |
FStar.Pervasives.Lemma | val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime | val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r = | false | null | true | let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = ((pow51 * pow51) * pow51) * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert (((((pow51 * pow51) * pow51) * pow51) * as_nat5 r) % prime ==
(pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert (((((pow51 * pow51) * pow51) * pow51) * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51
(as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51
(as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.u64",
"Spec.Curve25519.prime",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51_pow51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_5"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51_pow51_pow51 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ r1 r2 r3 r4 = _ in
Lib.IntTypes.v r4 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r3 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r2 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51 /\
Lib.IntTypes.v r1 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51)
<:
Type0))
(ensures
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
(((Hacl.Spec.Curve25519.Field51.Definition.pow51 *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r1 *! Lib.IntTypes.u64 19,
r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0) %
Spec.Curve25519.prime)
<:
Type0)) | {
"end_col": 124,
"end_line": 203,
"start_col": 43,
"start_line": 192
} |
FStar.Pervasives.Lemma | val mul64_wide_add3_lemma:
#m0:scale64 -> #m1:scale64 -> #m2:scale64
-> #m3:scale64 -> #m4:scale64 -> #m5:scale64
-> a0:uint64{felem_fits1 a0 m0}
-> a1:uint64{felem_fits1 a1 m1}
-> b0:uint64{felem_fits1 b0 m2}
-> b1:uint64{felem_fits1 b1 m3}
-> c0:uint64{felem_fits1 c0 m4}
-> c1:uint64{felem_fits1 c1 m5}
-> Lemma
(requires m0 * m1 + m2 * m3 + m4 * m5 < pow2 13)
(ensures
v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 128 /\
(v a0 * v a1 + v b0 * v b1 + v c0 * v c1) <=
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mul64_wide_add3_lemma #m0 #m1 #m2 #m3 #m4 #m5 a0 a1 b0 b1 c0 c1 =
assert (pow51 = pow2 51);
lemma_mul_le (v a0) (m0 * max51) (v a1) (m1 * max51);
lemma_mul_le (v b0) (m2 * max51) (v b1) (m3 * max51);
lemma_mul_le (v c0) (m4 * max51) (v c1) (m5 * max51);
lemma_add_le (v a0 * v a1) (m0 * max51 * m1 * max51) (v b0 * v b1) (m2 * max51 * m3 * max51);
lemma_add_le (v a0 * v a1 + v b0 * v b1) (m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51)
(v c0 * v c1) (m4 * max51 * m5 * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 <=
m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51 + m4 * max51 * m5 * max51);
assert_by_tactic (m0 * max51 * m1 * max51 + m2 * max51 * m3 * max51 + m4 * max51 * m5 * max51 ==
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51) canon;
assert_norm (pow2 13 > 0);
lemma_mul_le (m0 * m1 + m2 * m3 + m4 * m5) (pow2 13 - 1) (max51 * max51) (max51 * max51);
assert ((m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51 < pow2 13 * max51 * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 13 * max51 * max51);
assert_norm (pow2 13 * pow2 51 * pow2 51 = pow2 115);
assert_norm (pow2 115 < pow2 128) | val mul64_wide_add3_lemma:
#m0:scale64 -> #m1:scale64 -> #m2:scale64
-> #m3:scale64 -> #m4:scale64 -> #m5:scale64
-> a0:uint64{felem_fits1 a0 m0}
-> a1:uint64{felem_fits1 a1 m1}
-> b0:uint64{felem_fits1 b0 m2}
-> b1:uint64{felem_fits1 b1 m3}
-> c0:uint64{felem_fits1 c0 m4}
-> c1:uint64{felem_fits1 c1 m5}
-> Lemma
(requires m0 * m1 + m2 * m3 + m4 * m5 < pow2 13)
(ensures
v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 128 /\
(v a0 * v a1 + v b0 * v b1 + v c0 * v c1) <=
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51)
let mul64_wide_add3_lemma #m0 #m1 #m2 #m3 #m4 #m5 a0 a1 b0 b1 c0 c1 = | false | null | true | assert (pow51 = pow2 51);
lemma_mul_le (v a0) (m0 * max51) (v a1) (m1 * max51);
lemma_mul_le (v b0) (m2 * max51) (v b1) (m3 * max51);
lemma_mul_le (v c0) (m4 * max51) (v c1) (m5 * max51);
lemma_add_le (v a0 * v a1) (((m0 * max51) * m1) * max51) (v b0 * v b1) (((m2 * max51) * m3) * max51);
lemma_add_le (v a0 * v a1 + v b0 * v b1)
(((m0 * max51) * m1) * max51 + ((m2 * max51) * m3) * max51)
(v c0 * v c1)
(((m4 * max51) * m5) * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 <=
((m0 * max51) * m1) * max51 + ((m2 * max51) * m3) * max51 + ((m4 * max51) * m5) * max51);
assert_by_tactic (((m0 * max51) * m1) * max51 + ((m2 * max51) * m3) * max51 +
((m4 * max51) * m5) * max51 ==
((m0 * m1 + m2 * m3 + m4 * m5) * max51) * max51)
canon;
assert_norm (pow2 13 > 0);
lemma_mul_le (m0 * m1 + m2 * m3 + m4 * m5) (pow2 13 - 1) (max51 * max51) (max51 * max51);
assert (((m0 * m1 + m2 * m3 + m4 * m5) * max51) * max51 < (pow2 13 * max51) * max51);
assert (v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < (pow2 13 * max51) * max51);
assert_norm ((pow2 13 * pow2 51) * pow2 51 = pow2 115);
assert_norm (pow2 115 < pow2 128) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.scale64",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits1",
"FStar.Pervasives.assert_norm",
"Prims.op_LessThan",
"Prims.pow2",
"Prims.unit",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims._assert",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.max51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_le",
"Prims.op_Subtraction",
"Prims.op_GreaterThan",
"FStar.Tactics.Effect.assert_by_tactic",
"Prims.eq2",
"FStar.Tactics.Canon.canon",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_add_le",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204)
val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem0 f =
assert_norm (pow51 = pow2 51);
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64 * pow2 64 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 64 * pow2 64 * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f
val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow51 = pow2 51);
let o0 = f0 |. (f1 <<. 51ul) in
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f1) 64 51;
logor_disjoint f0 (f1 <<. 51ul) 51;
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
FStar.Math.Lemmas.lemma_div_lt (v f1) 51 13;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 38;
FStar.Math.Lemmas.multiple_modulo_lemma (v f2 % pow2 26) (pow2 38);
logor_disjoint (f1 >>. 13ul) (f2 <<. 38ul) 38;
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 51 26;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f3) 64 25;
FStar.Math.Lemmas.multiple_modulo_lemma (v f3 % pow2 39) (pow2 25);
logor_disjoint (f2 >>. 26ul) (f3 <<. 25ul) 25;
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
FStar.Math.Lemmas.lemma_div_lt (v f3) 51 39;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 12;
FStar.Math.Lemmas.multiple_modulo_lemma (v f4 % pow2 52) (pow2 12);
logor_disjoint (f3 >>. 39ul) (f4 <<. 12ul) 12;
lemma_store_felem0 f
val lemma_cswap2_step:
bit:uint64{v bit <= 1}
-> p1:uint64
-> p2:uint64
-> Lemma (
let mask = u64 0 -. bit in
let dummy = mask &. (p1 ^. p2) in
let p1' = p1 ^. dummy in
let p2' = p2 ^. dummy in
if v bit = 1 then p1' == p2 /\ p2' == p1 else p1' == p1 /\ p2' == p2)
let lemma_cswap2_step bit p1 p2 =
let mask = u64 0 -. bit in
assert (v bit == 0 ==> v mask == 0);
assert (v bit == 1 ==> v mask == pow2 64 - 1);
let dummy = mask &. (p1 ^. p2) in
logand_lemma mask (p1 ^. p2);
assert (v bit == 1 ==> v dummy == v (p1 ^. p2));
assert (v bit == 0 ==> v dummy == 0);
let p1' = p1 ^. dummy in
assert (v dummy == v (if v bit = 1 then (p1 ^. p2) else u64 0));
logxor_lemma p1 p2;
let p2' = p2 ^. dummy in
logxor_lemma p2 p1
#push-options "--max_fuel 0 --max_ifuel 0"
val mul64_wide_add3_lemma:
#m0:scale64 -> #m1:scale64 -> #m2:scale64
-> #m3:scale64 -> #m4:scale64 -> #m5:scale64
-> a0:uint64{felem_fits1 a0 m0}
-> a1:uint64{felem_fits1 a1 m1}
-> b0:uint64{felem_fits1 b0 m2}
-> b1:uint64{felem_fits1 b1 m3}
-> c0:uint64{felem_fits1 c0 m4}
-> c1:uint64{felem_fits1 c1 m5}
-> Lemma
(requires m0 * m1 + m2 * m3 + m4 * m5 < pow2 13)
(ensures
v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 128 /\
(v a0 * v a1 + v b0 * v b1 + v c0 * v c1) <=
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val mul64_wide_add3_lemma:
#m0:scale64 -> #m1:scale64 -> #m2:scale64
-> #m3:scale64 -> #m4:scale64 -> #m5:scale64
-> a0:uint64{felem_fits1 a0 m0}
-> a1:uint64{felem_fits1 a1 m1}
-> b0:uint64{felem_fits1 b0 m2}
-> b1:uint64{felem_fits1 b1 m3}
-> c0:uint64{felem_fits1 c0 m4}
-> c1:uint64{felem_fits1 c1 m5}
-> Lemma
(requires m0 * m1 + m2 * m3 + m4 * m5 < pow2 13)
(ensures
v a0 * v a1 + v b0 * v b1 + v c0 * v c1 < pow2 128 /\
(v a0 * v a1 + v b0 * v b1 + v c0 * v c1) <=
(m0 * m1 + m2 * m3 + m4 * m5) * max51 * max51) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.mul64_wide_add3_lemma | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a0: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 a0 m0} ->
a1: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 a1 m1} ->
b0: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 b0 m2} ->
b1: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 b1 m3} ->
c0: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 c0 m4} ->
c1: Lib.IntTypes.uint64{Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 c1 m5}
-> FStar.Pervasives.Lemma (requires m0 * m1 + m2 * m3 + m4 * m5 < Prims.pow2 13)
(ensures
Lib.IntTypes.v a0 * Lib.IntTypes.v a1 + Lib.IntTypes.v b0 * Lib.IntTypes.v b1 +
Lib.IntTypes.v c0 * Lib.IntTypes.v c1 <
Prims.pow2 128 /\
Lib.IntTypes.v a0 * Lib.IntTypes.v a1 + Lib.IntTypes.v b0 * Lib.IntTypes.v b1 +
Lib.IntTypes.v c0 * Lib.IntTypes.v c1 <=
((m0 * m1 + m2 * m3 + m4 * m5) * Hacl.Spec.Curve25519.Field51.Definition.max51) *
Hacl.Spec.Curve25519.Field51.Definition.max51) | {
"end_col": 35,
"end_line": 942,
"start_col": 2,
"start_line": 925
} |
FStar.Pervasives.Lemma | val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51 | val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin = | false | null | true | let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51 | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.pow2_minus",
"Prims.unit",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.Curve25519.Field51.Definition.mask51",
"Lib.IntTypes.mod_mask_lemma",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Plus_Bang"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\ | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_carry51 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | l: Lib.IntTypes.uint64 -> cin: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(requires
Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 l 2 /\
Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 cin 8190)
(ensures
(let l0 = l +! cin &. Hacl.Spec.Curve25519.Field51.Definition.mask51 in
let l1 = l +! cin >>. 51ul in
Lib.IntTypes.v l + Lib.IntTypes.v cin ==
Lib.IntTypes.v l1 * Prims.pow2 51 + Lib.IntTypes.v l0 /\
Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 l0 1 /\
Lib.IntTypes.v l1 < Prims.pow2 13)) | {
"end_col": 36,
"end_line": 465,
"start_col": 25,
"start_line": 457
} |
FStar.Pervasives.Lemma | val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime | val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let r0, r1, r2, r3, r4 = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r + (v f11 * pow51) * as_nat5 r + ((v f12 * pow51) * pow51) * as_nat5 r +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r) %
prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l ((v f11 * pow51) * as_nat5 r)
(v f10 * as_nat5 r + ((v f12 * pow51) * pow51) * as_nat5 r +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r + ((v f12 * pow51) * pow51) * as_nat5 r +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.u64",
"Prims.op_Addition",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_3",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Hacl.Spec.Curve25519.Field51.Definition.max51"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_1 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (9, 10, 9, 9, 9)} ->
r:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 r (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(requires
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ _ _ _ = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
(Lib.IntTypes.v f11 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((Lib.IntTypes.v f12 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
(((Lib.IntTypes.v f13 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0))
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
((Lib.IntTypes.v f12 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
(((Lib.IntTypes.v f13 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0)) | {
"end_col": 61,
"end_line": 248,
"start_col": 24,
"start_line": 225
} |
FStar.Pervasives.Lemma | val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime) | val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 + (v f11 + 0x3ffffffffffff8) * pow51 +
((v f12 + 0x3ffffffffffff8) * pow51) * pow51 +
(((v f13 + 0x3ffffffffffff8) * pow51) * pow51) * pow51 +
((((v f14 + 0x3ffffffffffff8) * pow51) * pow51) * pow51) * pow51) %
prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 ((pow51 * pow51) * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14)
0x3ffffffffffff8
(((pow51 * pow51) * pow51) * pow51);
assert_norm (0x3fffffffffff68 + 0x3ffffffffffff8 * pow51 + (0x3ffffffffffff8 * pow51) * pow51 +
((0x3ffffffffffff8 * pow51) * pow51) * pow51 +
(((0x3ffffffffffff8 * pow51) * pow51) * pow51) * pow51 =
8 * prime);
assert (feval out ==
(v f10 + v f11 * pow51 + (v f12 * pow51) * pow51 + ((v f13 * pow51) * pow51) * pow51 +
(((v f14 * pow51) * pow51) * pow51) * pow51 +
8 * prime) %
prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out ==
(v f10 + v f11 * pow51 + (v f12 * pow51) * pow51 + ((v f13 * pow51) * pow51) * pow51 +
(((v f14 * pow51) * pow51) * pow51) * pow51) %
prime) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Hacl.Spec.Curve25519.Field51.Definition.feval",
"Prims.op_Modulus",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_plus",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"FStar.Math.Lemmas.distributivity_add_left",
"FStar.Pervasives.Native.tuple5",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.u64"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_add_zero | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (1, 2, 1, 1, 1)}
-> FStar.Pervasives.Lemma
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let o0 = f10 +! Lib.IntTypes.u64 0x3fffffffffff68 in
let o1 = f11 +! Lib.IntTypes.u64 0x3ffffffffffff8 in
let o2 = f12 +! Lib.IntTypes.u64 0x3ffffffffffff8 in
let o3 = f13 +! Lib.IntTypes.u64 0x3ffffffffffff8 in
let o4 = f14 +! Lib.IntTypes.u64 0x3ffffffffffff8 in
let out = o0, o1, o2, o3, o4 in
Hacl.Spec.Curve25519.Field51.Definition.feval out ==
Hacl.Spec.Curve25519.Field51.Definition.feval f1)
<:
Type0)) | {
"end_col": 51,
"end_line": 116,
"start_col": 23,
"start_line": 86
} |
FStar.Pervasives.Lemma | val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime | val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = (pow51 * pow51) * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) + v f12 * p51p51r +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r) %
prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12)
(as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
(((v f13 * pow51) * pow51) * pow51) * as_nat5 r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.u64",
"Prims.op_Addition",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_4"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_2 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (9, 10, 9, 9, 9)} ->
r:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 r (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(requires
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
((Lib.IntTypes.v f12 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
(((Lib.IntTypes.v f13 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0))
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
(((Lib.IntTypes.v f13 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0)) | {
"end_col": 61,
"end_line": 294,
"start_col": 24,
"start_line": 270
} |
FStar.Pervasives.Lemma | val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime | val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let r0, r1, r2, r3, r4 = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + (v f12 * pow51) * pow51 + ((v f13 * pow51) * pow51) * pow51 +
(((v f14 * pow51) * pow51) * pow51) * pow51) *
as_nat5 r %
prime);
lemma_mul5_distr_r (v f10)
(v f11 * pow51)
((v f12 * pow51) * pow51)
(((v f13 * pow51) * pow51) * pow51)
((((v f14 * pow51) * pow51) * pow51) * pow51)
(as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims.op_Modulus",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_l",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_4",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_3",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_2",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_1",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul5_distr_r",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (9, 10, 9, 9, 9)} ->
r:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 r (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Spec.Curve25519.fmul (Hacl.Spec.Curve25519.Field51.Definition.feval f1)
(Hacl.Spec.Curve25519.Field51.Definition.feval r) ==
(Lib.IntTypes.v f10 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r0, r1, r2, r3, r4) +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
Lib.IntTypes.v f13 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1) +
Lib.IntTypes.v f14 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r1 *! Lib.IntTypes.u64 19,
r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0)) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0)) | {
"end_col": 80,
"end_line": 413,
"start_col": 22,
"start_line": 400
} |
FStar.Pervasives.Lemma | val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow51 = pow2 51);
let o0 = f0 |. (f1 <<. 51ul) in
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f1) 64 51;
logor_disjoint f0 (f1 <<. 51ul) 51;
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
FStar.Math.Lemmas.lemma_div_lt (v f1) 51 13;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 38;
FStar.Math.Lemmas.multiple_modulo_lemma (v f2 % pow2 26) (pow2 38);
logor_disjoint (f1 >>. 13ul) (f2 <<. 38ul) 38;
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 51 26;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f3) 64 25;
FStar.Math.Lemmas.multiple_modulo_lemma (v f3 % pow2 39) (pow2 25);
logor_disjoint (f2 >>. 26ul) (f3 <<. 25ul) 25;
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
FStar.Math.Lemmas.lemma_div_lt (v f3) 51 39;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 12;
FStar.Math.Lemmas.multiple_modulo_lemma (v f4 % pow2 52) (pow2 12);
logor_disjoint (f3 >>. 39ul) (f4 <<. 12ul) 12;
lemma_store_felem0 f | val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem f = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert_norm (pow51 = pow2 51);
let o0 = f0 |. (f1 <<. 51ul) in
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f1) 64 51;
logor_disjoint f0 (f1 <<. 51ul) 51;
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
FStar.Math.Lemmas.lemma_div_lt (v f1) 51 13;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f2) 64 38;
FStar.Math.Lemmas.multiple_modulo_lemma (v f2 % pow2 26) (pow2 38);
logor_disjoint (f1 >>. 13ul) (f2 <<. 38ul) 38;
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
FStar.Math.Lemmas.lemma_div_lt (v f2) 51 26;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f3) 64 25;
FStar.Math.Lemmas.multiple_modulo_lemma (v f3 % pow2 39) (pow2 25);
logor_disjoint (f2 >>. 26ul) (f3 <<. 25ul) 25;
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
FStar.Math.Lemmas.lemma_div_lt (v f3) 51 39;
FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2 (v f4) 64 12;
FStar.Math.Lemmas.multiple_modulo_lemma (v f4 % pow2 52) (pow2 12);
logor_disjoint (f3 >>. 39ul) (f4 <<. 12ul) 12;
lemma_store_felem0 f | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Prims.l_and",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Spec.Curve25519.prime",
"Lib.IntTypes.uint64",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem0",
"Prims.unit",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Less_Less_Dot",
"FStar.Math.Lemmas.multiple_modulo_lemma",
"Prims.op_Modulus",
"Lib.IntTypes.v",
"Prims.pow2",
"FStar.Math.Lemmas.pow2_multiplication_modulo_lemma_2",
"FStar.Math.Lemmas.lemma_div_lt",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Bar_Dot",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204)
val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem0 f =
assert_norm (pow51 = pow2 51);
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64 * pow2 64 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 64 * pow2 64 * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f
val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = f0 |. (f1 <<. 51ul) in
let o1 = (f1 >>. 13ul) |. (f2 <<. 38ul) in
let o2 = (f2 >>. 26ul) |. (f3 <<. 25ul) in
let o3 = (f3 >>. 39ul) |. (f4 <<. 12ul) in
as_nat5 f == v o0 + v o1 * pow2 64 + v o2 * pow2 64 * pow2 64 + v o3 * pow2 64 * pow2 64 * pow2 64) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{ Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1) /\
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f < Spec.Curve25519.prime }
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let o0 = f0 |. f1 <<. 51ul in
let o1 = f1 >>. 13ul |. f2 <<. 38ul in
let o2 = f2 >>. 26ul |. f3 <<. 25ul in
let o3 = f3 >>. 39ul |. f4 <<. 12ul in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f ==
Lib.IntTypes.v o0 + Lib.IntTypes.v o1 * Prims.pow2 64 +
(Lib.IntTypes.v o2 * Prims.pow2 64) * Prims.pow2 64 +
((Lib.IntTypes.v o3 * Prims.pow2 64) * Prims.pow2 64) * Prims.pow2 64)
<:
Type0)) | {
"end_col": 22,
"end_line": 882,
"start_col": 25,
"start_line": 858
} |
FStar.Pervasives.Lemma | val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime | val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r = | false | null | true | let r0, r1, r2, r3, r4 = r in
assert (pow51 * as_nat5 r ==
pow51 *
(v r0 + v r1 * pow51 + (v r2 * pow51) * pow51 + ((v r3 * pow51) * pow51) * pow51 +
(((v r4 * pow51) * pow51) * pow51) * pow51));
lemma_mul5_distr_l pow51
(v r0)
(v r1 * pow51)
((v r2 * pow51) * pow51)
(((v r3 * pow51) * pow51) * pow51)
((((v r4 * pow51) * pow51) * pow51) * pow51);
let p51r0123 =
pow51 * v r0 + (pow51 * v r1) * pow51 + ((pow51 * v r2) * pow51) * pow51 +
(((pow51 * v r3) * pow51) * pow51) * pow51
in
let p51r4 = ((((pow51 * v r4) * pow51) * pow51) * pow51) * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.pow2",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_prime",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims._assert",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Prims.op_Addition",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul5_distr_l"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(requires
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ _ _ _ _ r4 = _ in
Lib.IntTypes.v r4 * 19 <= 190 * Hacl.Spec.Curve25519.Field51.Definition.pow51)
<:
Type0))
(ensures
(let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.pow51 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) %
Spec.Curve25519.prime)
<:
Type0)) | {
"end_col": 69,
"end_line": 141,
"start_col": 25,
"start_line": 124
} |
FStar.Pervasives.Lemma | val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime | val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 = | false | null | true | assert_norm (pow51 = pow2 51);
assert (v c0 * pow2 51 + v t0 + (v c1 * pow2 51 + v t1 - v c0) * pow51 +
((v c2 * pow2 51 + v t2 - v c1) * pow51) * pow51 +
(((v c3 * pow2 51 + v t3 - v c2) * pow51) * pow51) * pow51 +
((((v c4 * pow2 51 + v t4 - v c3) * pow51) * pow51) * pow51) * pow51 ==
v t0 + v t1 * pow51 + (v t2 * pow51) * pow51 + ((v t3 * pow51) * pow51) * pow51 +
(((v t4 * pow51) * pow51) * pow51) * pow51 +
((((v c4 * pow2 51) * pow51) * pow51) * pow51) * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r (v t0 + v t1 * pow51 + (v t2 * pow51) * pow51 +
((v t3 * pow51) * pow51) * pow51 +
(((v t4 * pow51) * pow51) * pow51) * pow51)
(((((v c4 * pow2 51) * pow51) * pow51) * pow51) * pow51)
prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm ((((pow2 51 * pow51) * pow51) * pow51) * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r (v t0 + v t1 * pow51 + (v t2 * pow51) * pow51 +
((v t3 * pow51) * pow51) * pow51 +
(((v t4 * pow51) * pow51) * pow51) * pow51)
(v c4 * 19)
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.pow2",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_prime",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Prims.b2t",
"Prims.op_Equality",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_6",
"Prims._assert",
"Prims.op_Subtraction",
"Prims.pos"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_carry5_simplify | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
c0: Lib.IntTypes.uint64 ->
c1: Lib.IntTypes.uint64 ->
c2: Lib.IntTypes.uint64 ->
c3: Lib.IntTypes.uint64 ->
c4: Lib.IntTypes.uint64 ->
t0: Lib.IntTypes.uint64 ->
t1: Lib.IntTypes.uint64 ->
t2: Lib.IntTypes.uint64 ->
t3: Lib.IntTypes.uint64 ->
t4: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(Lib.IntTypes.v c0 * Prims.pow2 51 + Lib.IntTypes.v t0 +
(Lib.IntTypes.v c1 * Prims.pow2 51 + Lib.IntTypes.v t1 - Lib.IntTypes.v c0) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
((Lib.IntTypes.v c2 * Prims.pow2 51 + Lib.IntTypes.v t2 - Lib.IntTypes.v c1) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
(((Lib.IntTypes.v c3 * Prims.pow2 51 + Lib.IntTypes.v t3 - Lib.IntTypes.v c2) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
((((Lib.IntTypes.v c4 * Prims.pow2 51 + Lib.IntTypes.v t4 - Lib.IntTypes.v c3) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) %
Spec.Curve25519.prime ==
(Lib.IntTypes.v t0 + Lib.IntTypes.v c4 * 19 +
Lib.IntTypes.v t1 * Hacl.Spec.Curve25519.Field51.Definition.pow51 +
(Lib.IntTypes.v t2 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
((Lib.IntTypes.v t3 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51 +
(((Lib.IntTypes.v t4 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) %
Spec.Curve25519.prime) | {
"end_col": 20,
"end_line": 525,
"start_col": 2,
"start_line": 500
} |
FStar.Pervasives.Lemma | val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51) | val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin = | false | null | true | let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.scale64",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.uint128",
"Hacl.Spec.Curve25519.Field51.Definition.felem_wide_fits1",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.IntTypes.v",
"Lib.IntTypes.U128",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.mod_mask",
"FStar.UInt32.__uint_to_t",
"Hacl.Spec.Curve25519.Field51.Definition.mask51",
"Lib.IntTypes.mod_mask_lemma",
"Lib.IntTypes.to_u64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.op_Greater_Greater_Dot",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.to_u128"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\ | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_carry51_wide | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
l: Lib.IntTypes.uint128{Hacl.Spec.Curve25519.Field51.Definition.felem_wide_fits1 l m} ->
cin: Lib.IntTypes.uint64
-> FStar.Pervasives.Lemma
(ensures
(let l' = l +! Lib.IntTypes.to_u128 cin in
let l0 = Lib.IntTypes.to_u64 l' &. Hacl.Spec.Curve25519.Field51.Definition.mask51 in
let l1 = Lib.IntTypes.to_u64 (l' >>. 51ul) in
Lib.IntTypes.v l + Lib.IntTypes.v cin ==
Lib.IntTypes.v l1 * Prims.pow2 51 + Lib.IntTypes.v l0 /\
Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 l0 1 /\
Hacl.Spec.Curve25519.Field51.Definition.felem_fits1 l1 (m + 1))) | {
"end_col": 66,
"end_line": 486,
"start_col": 33,
"start_line": 477
} |
FStar.Pervasives.Lemma | val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime | val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = ((pow51 * pow51) * pow51) * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r) %
prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13)
(as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 *
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
((((v f14 * pow51) * pow51) * pow51) * pow51) * as_nat5 r)
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.u64",
"Prims.op_Addition",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_5"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_3 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (9, 10, 9, 9, 9)} ->
r:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 r (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(requires
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
(((Lib.IntTypes.v f13 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0))
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
Lib.IntTypes.v f13 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1) +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0)) | {
"end_col": 61,
"end_line": 340,
"start_col": 24,
"start_line": 316
} |
FStar.Pervasives.Lemma | val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39) | val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.euclidean_division_definition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 == | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem2 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Lib.IntTypes.v f0 + (Lib.IntTypes.v f1 % Prims.pow2 13) * Prims.pow2 51 +
(Lib.IntTypes.v f1 / Prims.pow2 13) * Prims.pow2 64 +
(Lib.IntTypes.v f2 % Prims.pow2 26) * Prims.pow2 102 +
(Lib.IntTypes.v f2 / Prims.pow2 26) * Prims.pow2 128 +
(Lib.IntTypes.v f3 % Prims.pow2 39) * Prims.pow2 153 +
(Lib.IntTypes.v f3 / Prims.pow2 39) * Prims.pow2 192 +
Lib.IntTypes.v f4 * Prims.pow2 204 ==
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Prims.pow2 51 + Lib.IntTypes.v f2 * Prims.pow2 102 +
Lib.IntTypes.v f3 * Prims.pow2 153 +
Lib.IntTypes.v f4 * Prims.pow2 204)
<:
Type0)) | {
"end_col": 66,
"end_line": 765,
"start_col": 26,
"start_line": 756
} |
FStar.Pervasives.Lemma | val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime | val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r = | false | null | true | let f10, f11, f12, f13, f14 = f1 in
let r0, r1, r2, r3, r4 = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = (((pow51 * pow51) * pow51) * pow51) * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) %
prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14)
(as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 *
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r + v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
prime | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Lib.IntTypes.uint64",
"FStar.Math.Lemmas.lemma_mod_plus_distr_l",
"FStar.Mul.op_Star",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Lib.IntTypes.op_Star_Bang",
"Lib.IntTypes.u64",
"Prims.op_Addition",
"Spec.Curve25519.prime",
"Prims.unit",
"FStar.Math.Lemmas.lemma_mod_mul_distr_r",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_pow51_pow51_pow51_pow51",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_6"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) + | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_fmul5_4 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f1:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f1 (9, 10, 9, 9, 9)} ->
r:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 r (9, 10, 9, 9, 9)}
-> FStar.Pervasives.Lemma
(requires
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
Lib.IntTypes.v f13 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1) +
((((Lib.IntTypes.v f14 * Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.pow51) *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0))
(ensures
(let _ = f1 in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f10 f11 f12 f13 f14 = _ in
let _ = r in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ r0 r1 r2 r3 r4 = _ in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f1 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r %
Spec.Curve25519.prime ==
(Lib.IntTypes.v f10 * Hacl.Spec.Curve25519.Field51.Definition.as_nat5 r +
Lib.IntTypes.v f11 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2,
r3) +
Lib.IntTypes.v f12 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1,
r2) +
Lib.IntTypes.v f13 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0,
r1) +
Lib.IntTypes.v f14 *
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 (r1 *! Lib.IntTypes.u64 19,
r2 *! Lib.IntTypes.u64 19,
r3 *! Lib.IntTypes.u64 19,
r4 *! Lib.IntTypes.u64 19,
r0)) %
Spec.Curve25519.prime)
<:
Type0)
<:
Type0)) | {
"end_col": 78,
"end_line": 386,
"start_col": 24,
"start_line": 362
} |
FStar.Pervasives.Lemma | val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192) | val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s = | false | null | true | let open Lib.Sequence in
let f0, f1, f2, f3, f4 = f in
let s0, s1, s2, s3 = (u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm ((pow2 26 * pow2 51) * pow2 51 = pow2 128);
assert_norm ((pow2 51 * pow2 51) * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (((pow2 39 * pow2 51) * pow2 51) * pow2 51 = pow2 192);
assert_norm (((pow2 51 * pow2 51) * pow2 51) * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm ((pow2 64 * pow2 64) * pow2 64 = pow2 192) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.unit",
"Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4",
"Prims._assert",
"Prims.eq2",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Prims.op_Addition",
"Lib.IntTypes.v",
"FStar.Math.Lemmas.euclidean_division_definition",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"FStar.Pervasives.Native.tuple4",
"FStar.Pervasives.Native.Mktuple4",
"Lib.Sequence.op_String_Access"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_load_felem5 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Curve25519.Field51.Definition.felem5 -> u64s: Lib.Sequence.lseq Lib.IntTypes.uint64 4
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let _ = u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ] in
(let FStar.Pervasives.Native.Mktuple4 #_ #_ #_ #_ s0 s1 s2 s3 = _ in
Lib.IntTypes.v f0 == Lib.IntTypes.v s0 % Prims.pow2 51 /\
Lib.IntTypes.v f1 ==
Lib.IntTypes.v s0 / Prims.pow2 51 +
(Lib.IntTypes.v s1 % Prims.pow2 38) * Prims.pow2 13 /\
Lib.IntTypes.v f2 ==
Lib.IntTypes.v s1 / Prims.pow2 38 +
(Lib.IntTypes.v s2 % Prims.pow2 25) * Prims.pow2 26 /\
Lib.IntTypes.v f3 ==
Lib.IntTypes.v s2 / Prims.pow2 25 +
(Lib.IntTypes.v s3 % Prims.pow2 12) * Prims.pow2 39 /\
Lib.IntTypes.v f4 == Lib.IntTypes.v s3 / Prims.pow2 12)
<:
Type0)
<:
Type0))
(ensures
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f ==
Lib.ByteSequence.nat_from_intseq_le u64s) | {
"end_col": 54,
"end_line": 559,
"start_col": 2,
"start_line": 542
} |
FStar.Pervasives.Lemma | val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s | val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s = | false | null | true | assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let s0, s1, s2, s3 = (u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Prims.pow2",
"Lib.IntTypes.int_t",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_load_felem5",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_load_felem_fits5",
"FStar.Pervasives.Native.tuple5",
"FStar.Pervasives.Native.Mktuple5",
"Lib.IntTypes.logor_disjoint",
"Lib.IntTypes.op_Bar_Dot",
"Lib.IntTypes.op_Greater_Greater_Dot",
"FStar.UInt32.__uint_to_t",
"FStar.Math.Lemmas.modulo_lemma",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"Prims._assert",
"Prims.eq2",
"Lib.IntTypes.range_t",
"Lib.IntTypes.mod_mask",
"Lib.IntTypes.u64",
"Lib.IntTypes.mod_mask_lemma",
"FStar.Math.Lemmas.pow2_lt_compat",
"Lib.IntTypes.op_Less_Less_Dot",
"Lib.IntTypes.op_Amp_Dot",
"FStar.Math.Lemmas.lemma_div_lt",
"Hacl.Spec.Curve25519.Field51.Definition.mask51",
"FStar.Pervasives.Native.tuple4",
"FStar.Pervasives.Native.Mktuple4",
"Prims.op_Subtraction"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_load_felem | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | u64s: Lib.Sequence.lseq Lib.IntTypes.uint64 4 {Lib.IntTypes.v u64s.[ 3 ] < Prims.pow2 63}
-> FStar.Pervasives.Lemma
(ensures
(let _ = u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ] in
(let FStar.Pervasives.Native.Mktuple4 #_ #_ #_ #_ s0 s1 s2 s3 = _ in
let f0 = s0 &. Hacl.Spec.Curve25519.Field51.Definition.mask51 in
let f1 = s0 >>. 51ul |. (s1 &. Lib.IntTypes.u64 0x3fffffffff) <<. 13ul in
let f2 = s1 >>. 38ul |. (s2 &. Lib.IntTypes.u64 0x1ffffff) <<. 26ul in
let f3 = s2 >>. 25ul |. (s3 &. Lib.IntTypes.u64 0xfff) <<. 39ul in
let f4 = s3 >>. 12ul in
let f = f0, f1, f2, f3, f4 in
Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1) /\
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f ==
Lib.ByteSequence.nat_from_intseq_le u64s)
<:
Type0)) | {
"end_col": 26,
"end_line": 673,
"start_col": 2,
"start_line": 619
} |
FStar.Pervasives.Lemma | val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f | val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f = | false | null | true | let f0, f1, f2, f3, f4 = f in
assert (v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13) * pow2 64 +
((v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26) * pow2 128 +
((v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39) * pow2 192 +
(v f4 * pow2 12) * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert (((v f2 % pow2 26) * pow2 38) * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert (((v f3 % pow2 39) * pow2 25) * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert ((v f4 * pow2 12) * pow2 192 == v f4 * pow2 204);
assert (v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13) * pow2 64 +
((v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26) * pow2 128 +
((v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39) * pow2 192 +
(v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13) * pow2 64 + (v f2 % pow2 26) * pow2 102 +
(v f2 / pow2 26) * pow2 128 +
(v f3 % pow2 39) * pow2 153 +
(v f3 / pow2 39) * pow2 192 +
v f4 * pow2 204);
lemma_store_felem2 f | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.IntTypes.uint64",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem2",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.Mul.op_Star",
"Prims.op_Modulus",
"Prims.pow2",
"Prims.op_Division",
"FStar.Pervasives.assert_norm",
"Prims.b2t",
"Prims.op_Equality",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_assos_3"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 == | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem1 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Curve25519.Field51.Definition.felem5
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
Lib.IntTypes.v f0 + (Lib.IntTypes.v f1 % Prims.pow2 13) * Prims.pow2 51 +
(Lib.IntTypes.v f1 / Prims.pow2 13 + (Lib.IntTypes.v f2 % Prims.pow2 26) * Prims.pow2 38) *
Prims.pow2 64 +
(Lib.IntTypes.v f2 / Prims.pow2 26 + (Lib.IntTypes.v f3 % Prims.pow2 39) * Prims.pow2 25) *
Prims.pow2 128 +
(Lib.IntTypes.v f3 / Prims.pow2 39 + Lib.IntTypes.v f4 * Prims.pow2 12) * Prims.pow2 192 ==
Lib.IntTypes.v f0 + Lib.IntTypes.v f1 * Prims.pow2 51 + Lib.IntTypes.v f2 * Prims.pow2 102 +
Lib.IntTypes.v f3 * Prims.pow2 153 +
Lib.IntTypes.v f4 * Prims.pow2 204)
<:
Type0)) | {
"end_col": 22,
"end_line": 804,
"start_col": 26,
"start_line": 775
} |
FStar.Pervasives.Lemma | val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_store_felem0 f =
assert_norm (pow51 = pow2 51);
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64 * pow2 64 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 64 * pow2 64 * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192);
assert (
o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f | val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64)
let lemma_store_felem0 f = | false | null | true | assert_norm (pow51 = pow2 51);
let f0, f1, f2, f3, f4 = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
assert_norm (pow2 51 < pow2 52);
FStar.Math.Lemmas.modulo_lemma (v f4) (pow2 52);
assert (v f4 % pow2 52 = v f4);
assert (o0 + o1 * pow2 64 + (o2 * pow2 64) * pow2 64 + ((o3 * pow2 64) * pow2 64) * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
((v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 64) * pow2 64 +
(((v f3 / pow2 39 + v f4 * pow2 12) * pow2 64) * pow2 64) * pow2 64);
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm ((pow2 64 * pow2 64) * pow2 64 = pow2 192);
assert (o0 + o1 * pow2 64 + (o2 * pow2 64) * pow2 64 + ((o3 * pow2 64) * pow2 64) * pow2 64 ==
v f0 + (v f1 % pow2 13) * pow2 51 + (v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192);
lemma_store_felem1 f;
lemma_as_nat1 f | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Prims.l_and",
"Hacl.Spec.Curve25519.Field51.Definition.felem_fits5",
"FStar.Pervasives.Native.Mktuple5",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Spec.Curve25519.Field51.Definition.as_nat5",
"Spec.Curve25519.prime",
"Lib.IntTypes.uint64",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_as_nat1",
"Prims.unit",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem1",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.Mul.op_Star",
"Prims.pow2",
"Lib.IntTypes.v",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_Modulus",
"Prims.op_Division",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"FStar.Math.Lemmas.modulo_lemma",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51)
val lemma_load_felem: u64s:LSeq.lseq uint64 4{v (u64s.[3]) < pow2 63} ->
Lemma (
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0 = s0 &. mask51 in
let f1 = (s0 >>. 51ul) |. ((s1 &. u64 0x3fffffffff) <<. 13ul) in
let f2 = (s1 >>. 38ul) |. ((s2 &. u64 0x1ffffff) <<. 26ul) in
let f3 = (s2 >>. 25ul) |. ((s3 &. u64 0xfff) <<. 39ul) in
let f4 = s3 >>. 12ul in
let f = (f0, f1, f2, f3, f4) in
felem_fits5 f (1, 1, 1, 1, 1) /\
as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem u64s =
assert_norm (0x3fffffffff = pow2 38 - 1);
assert_norm (0x1ffffff = pow2 25 - 1);
assert_norm (0xfff = pow2 12 - 1);
let open Lib.Sequence in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
let f0l = s0 &. mask51 in
FStar.Math.Lemmas.pow2_lt_compat 64 51;
mod_mask_lemma s0 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
let f0h = s0 >>. 51ul in
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
let f1l = (s1 &. u64 0x3fffffffff) <<. 13ul in
FStar.Math.Lemmas.pow2_lt_compat 64 38;
mod_mask_lemma s1 38ul;
assert (v (mod_mask #U64 #SEC 38ul) == v (u64 0x3fffffffff));
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert_norm (pow2 51 < pow2 64);
FStar.Math.Lemmas.modulo_lemma ((v s1 % pow2 38) * pow2 13) (pow2 64);
let f1h = s1 >>. 38ul in
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
let f2l = (s2 &. u64 0x1ffffff) <<. 26ul in
FStar.Math.Lemmas.pow2_lt_compat 64 25;
mod_mask_lemma s2 25ul;
assert (v (mod_mask #U64 #SEC 25ul) == v (u64 0x1ffffff));
assert_norm (pow2 25 * pow2 26 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s2 % pow2 25) * pow2 26) (pow2 64);
let f2h = s2 >>. 25ul in
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
let f3l = (s3 &. u64 0xfff) <<. 39ul in
FStar.Math.Lemmas.pow2_lt_compat 64 12;
mod_mask_lemma s3 12ul;
assert (v (mod_mask #U64 #SEC 12ul) == v (u64 0xfff));
assert_norm (pow2 12 * pow2 39 = pow2 51);
FStar.Math.Lemmas.modulo_lemma ((v s3 % pow2 12) * pow2 39) (pow2 64);
let f3h = s3 >>. 12ul in
let f0 = f0l in
let f1 = f0h |. f1l in
logor_disjoint f0h f1l 13;
let f2 = f1h |. f2l in
logor_disjoint f1h f2l 26;
let f3 = f2h |. f3l in
logor_disjoint f2h f3l 39;
let f4 = f3h in
let f = (f0, f1, f2, f3, f4) in
lemma_load_felem_fits5 f u64s;
lemma_load_felem5 f u64s
val lemma_subtract_p5_0:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_0 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f == v f0 + v f1 * pow51 + v f2 * pow51 * pow51 +
v f3 * pow51 * pow51 * pow51 + v f4 * pow51 * pow51 * pow51 * pow51);
assert (as_nat5 f <= pow2 51 - 20 + (pow2 51 - 1) * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 +
(pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 + (pow2 51 - 1) * pow2 51 * pow2 51 * pow2 51 * pow2 51);
assert (as_nat5 f < pow2 255 - 19);
assert (as_nat5 f == as_nat5 f');
FStar.Math.Lemmas.modulo_lemma (as_nat5 f') prime
val lemma_subtract_p5_1:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p5_1 f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
assert_norm (0x7ffffffffffff = pow2 51 - 1);
assert_norm (0x7ffffffffffed = pow2 51 - 19);
assert_norm (pow51 = pow2 51);
assert (as_nat5 f' % prime == (v f0' + v f1' * pow51 + v f2' * pow51 * pow51 +
v f3' * pow51 * pow51 * pow51 + v f4' * pow51 * pow51 * pow51 * pow51) % prime);
assert (as_nat5 f' % prime ==
(v f0 - (pow2 51 - 19) + (v f1 - (pow2 51 - 1)) * pow2 51 + (v f2 - (pow2 51 - 1)) * pow2 51 * pow2 51 +
(v f3 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 +
(v f4 - (pow2 51 - 1)) * pow2 51 * pow2 51 * pow2 51 * pow2 51) % prime);
assert (as_nat5 f' % prime ==
(v f0 + v f1 * pow2 51 + v f2 * pow2 51 * pow2 51 +
v f3 * pow2 51 * pow2 51 * pow2 51 + v f4 * pow2 51 * pow2 51 * pow2 51 * pow2 51 - prime) % prime);
FStar.Math.Lemmas.lemma_mod_sub (as_nat5 f) 1 prime
val lemma_subtract_p:
f:felem5{felem_fits5 f (1, 1, 1, 1, 1)}
-> f':felem5
-> Lemma
(requires (
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
(((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) /\
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4)) \/
((v f4 = 0x7ffffffffffff && v f3 = 0x7ffffffffffff && v f2 = 0x7ffffffffffff && v f1 = 0x7ffffffffffff && v f0 >= 0x7ffffffffffed) /\
(v f0' = v f0 - 0x7ffffffffffed && v f1' = v f1 - 0x7ffffffffffff && v f2' = v f2 - 0x7ffffffffffff &&
v f3' = v f3 - 0x7ffffffffffff && v f4' = v f4 - 0x7ffffffffffff)))))
(ensures as_nat5 f' == as_nat5 f % prime)
let lemma_subtract_p f f' =
let (f0, f1, f2, f3, f4) = f in
let (f0', f1', f2', f3', f4') = f' in
if ((v f4 <> 0x7ffffffffffff || v f3 <> 0x7ffffffffffff || v f2 <> 0x7ffffffffffff || v f1 <> 0x7ffffffffffff || v f0 < 0x7ffffffffffed) &&
(v f0' = v f0 && v f1' = v f1 && v f2' = v f2 && v f3' = v f3 && v f4' = v f4))
then lemma_subtract_p5_0 f f'
else lemma_subtract_p5_1 f f'
val lemma_store_felem2: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem2 f =
let (f0, f1, f2, f3, f4) = f in
assert_norm (pow2 64 = pow2 13 * pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v f1) (pow2 13);
assert_norm (pow2 128 = pow2 26 * pow2 102);
FStar.Math.Lemmas.euclidean_division_definition (v f2) (pow2 26);
assert_norm (pow2 192 = pow2 39 * pow2 153);
FStar.Math.Lemmas.euclidean_division_definition (v f3) (pow2 39)
val lemma_store_felem1: f:felem5 ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_store_felem1 f =
let (f0, f1, f2, f3, f4) = f in
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
(v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38) * pow2 64 +
(v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25) * pow2 128 +
(v f3 / pow2 39 + v f4 * pow2 12) * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192);
lemma_mul_assos_3 (v f2 % pow2 26) (pow2 38) (pow2 64);
assert_norm (pow2 38 * pow2 64 = pow2 102);
assert ((v f2 % pow2 26) * pow2 38 * pow2 64 == (v f2 % pow2 26) * pow2 102);
lemma_mul_assos_3 (v f3 % pow2 39) (pow2 25) (pow2 128);
assert_norm (pow2 25 * pow2 128 = pow2 153);
assert ((v f3 % pow2 39) * pow2 25 * pow2 128 == (v f3 % pow2 39) * pow2 153);
lemma_mul_assos_3 (v f4) (pow2 12) (pow2 192);
assert_norm (pow2 12 * pow2 192 = pow2 204);
assert (v f4 * pow2 12 * pow2 192 == v f4 * pow2 204);
assert (
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 38 * pow2 64 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 25 * pow2 128 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 12 * pow2 192 ==
v f0 + (v f1 % pow2 13) * pow2 51 +
v f1 / pow2 13 * pow2 64 + (v f2 % pow2 26) * pow2 102 +
v f2 / pow2 26 * pow2 128 + (v f3 % pow2 39) * pow2 153 +
v f3 / pow2 39 * pow2 192 + v f4 * pow2 204);
lemma_store_felem2 f
val lemma_as_nat1: f:felem5 ->
Lemma (let (f0, f1, f2, f3, f4) = f in
as_nat5 f == v f0 + v f1 * pow2 51 + v f2 * pow2 102 + v f3 * pow2 153 + v f4 * pow2 204)
let lemma_as_nat1 f =
assert_norm (pow51 = pow2 51);
assert_norm (pow2 51 * pow2 51 = pow2 102);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 153);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 204)
val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_store_felem0: f:felem5{felem_fits5 f (1, 1, 1, 1, 1) /\ as_nat5 f < prime} ->
Lemma (
let (f0, f1, f2, f3, f4) = f in
let o0 = v f0 + (v f1 % pow2 13) * pow2 51 in
let o1 = v f1 / pow2 13 + (v f2 % pow2 26) * pow2 38 in
let o2 = v f2 / pow2 26 + (v f3 % pow2 39) * pow2 25 in
let o3 = v f3 / pow2 39 + (v f4 % pow2 52) * pow2 12 in
as_nat5 f == o0 + o1 * pow2 64 + o2 * pow2 64 * pow2 64 + o3 * pow2 64 * pow2 64 * pow2 64) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_store_felem0 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
f:
Hacl.Spec.Curve25519.Field51.Definition.felem5
{ Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1) /\
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f < Spec.Curve25519.prime }
-> FStar.Pervasives.Lemma
(ensures
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let o0 = Lib.IntTypes.v f0 + (Lib.IntTypes.v f1 % Prims.pow2 13) * Prims.pow2 51 in
let o1 =
Lib.IntTypes.v f1 / Prims.pow2 13 + (Lib.IntTypes.v f2 % Prims.pow2 26) * Prims.pow2 38
in
let o2 =
Lib.IntTypes.v f2 / Prims.pow2 26 + (Lib.IntTypes.v f3 % Prims.pow2 39) * Prims.pow2 25
in
let o3 =
Lib.IntTypes.v f3 / Prims.pow2 39 + (Lib.IntTypes.v f4 % Prims.pow2 52) * Prims.pow2 12
in
Hacl.Spec.Curve25519.Field51.Definition.as_nat5 f ==
o0 + o1 * Prims.pow2 64 + (o2 * Prims.pow2 64) * Prims.pow2 64 +
((o3 * Prims.pow2 64) * Prims.pow2 64) * Prims.pow2 64)
<:
Type0)) | {
"end_col": 17,
"end_line": 848,
"start_col": 2,
"start_line": 824
} |
FStar.Pervasives.Lemma | val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1)) | [
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.ByteSequence",
"short_module": "BSeq"
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51.Definition",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics.Canon",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Tactics",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Spec.Curve25519.Field51",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_load_felem_fits5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51) | val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1))
let lemma_load_felem_fits5 f u64s = | false | null | true | let open Lib.Sequence in
let f0, f1, f2, f3, f4 = f in
let s0, s1, s2, s3 = (u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ]) in
assert_norm (pow51 = pow2 51);
assert (v f0 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s3) 63 12;
assert (v f4 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s0) 64 51;
lemma_mul_le (v s1 % pow2 38) (pow2 38 - 1) (pow2 13) (pow2 13);
assert ((v s1 % pow2 38) * pow2 13 <= (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 13 - 1 + (pow2 38 - 1) * pow2 13);
assert (v f1 <= pow2 38 * pow2 13 - 1);
assert_norm (pow2 38 * pow2 13 = pow2 51);
assert (v f1 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s1) 64 38;
lemma_mul_le (v s2 % pow2 25) (pow2 25 - 1) (pow2 26) (pow2 26);
assert ((v s2 % pow2 25) * pow2 26 <= (pow2 25 - 1) * pow2 26);
assert (v f2 <= (pow2 26 - 1) + (pow2 25 - 1) * pow2 26);
assert (v f2 <= pow2 25 * pow2 26 - 1);
assert_norm (pow2 25 * pow2 26 = pow2 51);
assert (v f2 < pow2 51);
FStar.Math.Lemmas.lemma_div_lt (v s2) 64 25;
lemma_mul_le (v s3 % pow2 12) (pow2 12 - 1) (pow2 39) (pow2 39);
assert ((v s3 % pow2 12) * pow2 39 <= (pow2 12 - 1) * pow2 39);
assert (v f3 <= (pow2 39 - 1) + (pow2 12 - 1) * pow2 39);
assert (v f3 <= pow2 12 * pow2 39 - 1);
assert_norm (pow2 12 * pow2 39 = pow2 51);
assert (v f3 < pow2 51) | {
"checked_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Hacl.Spec.Curve25519.Field51.Definition.fst.checked",
"Hacl.Impl.Curve25519.Lemmas.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Tactics.Canon.fst.checked",
"FStar.Tactics.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Spec.Curve25519.Field51.Lemmas.fst"
} | [
"lemma"
] | [
"Hacl.Spec.Curve25519.Field51.Definition.felem5",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims._assert",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.v",
"Prims.pow2",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.op_Equality",
"Prims.int",
"FStar.Mul.op_Star",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.op_Addition",
"Prims.op_Modulus",
"Hacl.Spec.Curve25519.Field51.Lemmas.lemma_mul_le",
"FStar.Math.Lemmas.lemma_div_lt",
"Prims.pos",
"Hacl.Spec.Curve25519.Field51.Definition.pow51",
"FStar.Pervasives.Native.tuple4",
"FStar.Pervasives.Native.Mktuple4",
"Lib.Sequence.op_String_Access"
] | [] | module Hacl.Spec.Curve25519.Field51.Lemmas
open FStar.Mul
open Lib.Sequence
open Lib.IntTypes
open FStar.Tactics
open FStar.Tactics.Canon
open Spec.Curve25519
open Hacl.Spec.Curve25519.Field51.Definition
module BSeq = Lib.ByteSequence
module LSeq = Lib.Sequence
#reset-options "--z3rlimit 50 --using_facts_from '* -FStar.Seq -FStar.Tactics'"
val lemma_mod_sub_distr: a:int -> b:int -> n:pos ->
Lemma ((a - b % n) % n = (a - b) % n)
let lemma_mod_sub_distr a b n =
FStar.Math.Lemmas.lemma_div_mod b n;
FStar.Math.Lemmas.distributivity_sub_left 0 (b / n) n;
// (a - b) % n == (a - (b % n) - (b / n) * n) % n
FStar.Math.Lemmas.lemma_mod_plus (a - (b % n)) (-(b / n)) n
val lemma_mul5_distr_r:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma ((a + b + c + d + e) * f == a * f + b * f + c * f + d * f + e * f)
let lemma_mul5_distr_r a b c d e f = ()
val lemma_mul5_distr_l:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * (b + c + d + e + f) == a * b + a * c + a * d + a * e + a * f)
let lemma_mul5_distr_l a b c d e f = ()
val lemma_mul_assos_3:
a:nat -> b:nat -> c:nat ->
Lemma (a * b * c == a * (b * c))
let lemma_mul_assos_3 a b c = ()
val lemma_mul_assos_4:
a:nat -> b:nat -> c:nat -> d:nat ->
Lemma (a * b * c * d == a * (b * c * d))
let lemma_mul_assos_4 a b c d = ()
val lemma_mul_assos_5:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat ->
Lemma (a * b * c * d * e == a * (b * c * d * e))
let lemma_mul_assos_5 a b c d e = ()
val lemma_mul_assos_6:
a:nat -> b:nat -> c:nat -> d:nat -> e:nat -> f:nat ->
Lemma (a * b * c * d * e * f == a * (b * c * d * e * f))
let lemma_mul_assos_6 a b c d e f = ()
val lemma_add_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a + c <= b + d)
let lemma_add_le a b c d = ()
val lemma_mul_le:a:nat -> b:nat -> c:nat -> d:nat ->
Lemma
(requires a <= b /\ c <= d)
(ensures a * c <= b * d)
let lemma_mul_le a b c d = ()
val lemma_prime: unit ->
Lemma (pow2 255 % prime = 19)
let lemma_prime () =
assert_norm (pow2 255 % prime = 19 % prime);
assert_norm (19 < prime);
FStar.Math.Lemmas.modulo_lemma 19 prime
val lemma_add_zero:
f1:felem5{felem_fits5 f1 (1, 2, 1, 1, 1)}
-> Lemma (
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
feval out == feval f1)
let lemma_add_zero f1 =
let (f10, f11, f12, f13, f14) = f1 in
let o0 = f10 +! u64 0x3fffffffffff68 in
let o1 = f11 +! u64 0x3ffffffffffff8 in
let o2 = f12 +! u64 0x3ffffffffffff8 in
let o3 = f13 +! u64 0x3ffffffffffff8 in
let o4 = f14 +! u64 0x3ffffffffffff8 in
let out = (o0, o1, o2, o3, o4) in
assert (feval out ==
(v f10 + 0x3fffffffffff68 +
(v f11 + 0x3ffffffffffff8) * pow51 +
(v f12 + 0x3ffffffffffff8) * pow51 * pow51 +
(v f13 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 +
(v f14 + 0x3ffffffffffff8) * pow51 * pow51 * pow51 * pow51) % prime);
FStar.Math.Lemmas.distributivity_add_left (v f11) 0x3ffffffffffff8 pow51;
FStar.Math.Lemmas.distributivity_add_left (v f12) 0x3ffffffffffff8 (pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f13) 0x3ffffffffffff8 (pow51 * pow51 * pow51);
FStar.Math.Lemmas.distributivity_add_left (v f14) 0x3ffffffffffff8 (pow51 * pow51 * pow51 * pow51);
assert_norm (
0x3fffffffffff68 +
0x3ffffffffffff8 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 +
0x3ffffffffffff8 * pow51 * pow51 * pow51 * pow51 = 8 * prime);
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51 + 8 * prime) % prime);
FStar.Math.Lemmas.lemma_mod_plus (as_nat5 f1) 8 prime;
assert (feval out == (v f10 + v f11 * pow51 +
v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) % prime)
val lemma_fmul5_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * as_nat5 r) % prime == as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime))
let lemma_fmul5_pow51 r =
let (r0, r1, r2, r3, r4) = r in
assert (pow51 * as_nat5 r == pow51 * (v r0 + v r1 * pow51 + v r2 * pow51 * pow51 +
v r3 * pow51 * pow51 * pow51 + v r4 * pow51 * pow51 * pow51 * pow51));
lemma_mul5_distr_l pow51 (v r0) (v r1 * pow51) (v r2 * pow51 * pow51)
(v r3 * pow51 * pow51 * pow51) (v r4 * pow51 * pow51 * pow51 * pow51);
let p51r0123 = pow51 * v r0 + pow51 * v r1 * pow51 +
pow51 * v r2 * pow51 * pow51 + pow51 * v r3 * pow51 * pow51 * pow51 in
let p51r4 = pow51 * v r4 * pow51 * pow51 * pow51 * pow51 in
assert ((pow51 * as_nat5 r) % prime == (p51r0123 + p51r4) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 p51r4 prime;
assert_norm (p51r4 % prime == (v r4 * pow2 255) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v r4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v r4 * pow2 255) % prime == (v r4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r p51r0123 (v r4 * 19) prime
val lemma_fmul5_pow51_pow51:r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime))
let lemma_fmul5_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_3 pow51 pow51 (as_nat5 r);
let p51r = pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51r prime;
assert ((pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51r % prime)) % prime);
lemma_fmul5_pow51 r;
assert ((pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r4 *! u64 19, r0, r1, r2, r3) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
lemma_fmul5_pow51 (r4 *! u64 19, r0, r1, r2, r3);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime
val lemma_fmul5_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime))
let lemma_fmul5_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 pow51 pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51r prime;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
lemma_fmul5_pow51 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5_pow51_pow51_pow51_pow51: r:felem5
-> Lemma
(requires (let (r0, r1, r2, r3, r4) = r in
v r4 * 19 <= 190 * pow51 /\ v r3 * 19 <= 190 * pow51 /\
v r2 * 19 <= 190 * pow51 /\ v r1 * 19 <= 190 * pow51))
(ensures (let (r0, r1, r2, r3, r4) = r in
(pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0) % prime))
let lemma_fmul5_pow51_pow51_pow51_pow51 r =
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 p51p51p51r prime;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime == (pow51 * (p51p51p51r % prime)) % prime);
lemma_fmul5_pow51_pow51_pow51 r;
assert ((pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime ==
(pow51 * (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) % prime)) % prime);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
lemma_fmul5_pow51 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1);
FStar.Math.Lemmas.lemma_mod_mul_distr_r pow51 (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime
val lemma_fmul5_1:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_1 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert (v r4 * 19 <= 190 * max51);
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * pow51 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * pow51 * as_nat5 r)
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
lemma_mul_assos_3 (v f11) pow51 (as_nat5 r);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (pow51 * as_nat5 r) prime;
lemma_fmul5_pow51 (r0, r1, r2, r3, r4);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f11) (as_nat5 (r4 *! u64 19, r0, r1, r2, r3)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3))
(v f10 * as_nat5 r +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_2:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * pow51 * pow51 * as_nat5 r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_2 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_4 (v f12) pow51 pow51 (as_nat5 r);
let p51p51r = pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * p51p51r +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) p51p51r prime;
lemma_fmul5_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f12) (as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_3:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * pow51 * pow51 * pow51 * as_nat5 r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
let lemma_fmul5_3 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_5 (v f13) pow51 pow51 pow51 (as_nat5 r);
let p51p51p51r = pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * p51p51p51r +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f13) (as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) prime
val lemma_fmul5_4:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(requires (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * pow51 * pow51 * pow51 * pow51 * as_nat5 r) % prime))
(ensures (let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
(as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime))
let lemma_fmul5_4 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
lemma_mul_assos_6 (v f14) pow51 pow51 pow51 pow51 (as_nat5 r);
let p51p51p51p51r = pow51 * pow51 * pow51 * pow51 * as_nat5 r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * p51p51p51p51r) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * p51p51p51p51r)
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) p51p51p51p51r prime;
lemma_fmul5_pow51_pow51_pow51_pow51 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v f14) (as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) prime;
FStar.Math.Lemmas.lemma_mod_plus_distr_l (v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0))
(v f10 * as_nat5 r +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1)) prime
val lemma_fmul5:
f1:felem5{felem_fits5 f1 (9, 10, 9, 9, 9)}
-> r:felem5{felem_fits5 r (9, 10, 9, 9, 9)}
-> Lemma
(let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
fmul (feval f1) (feval r) ==
(v f10 * as_nat5 (r0, r1, r2, r3, r4) +
v f11 * as_nat5 (r4 *! u64 19, r0, r1, r2, r3) +
v f12 * as_nat5 (r3 *! u64 19, r4 *! u64 19, r0, r1, r2) +
v f13 * as_nat5 (r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0, r1) +
v f14 * as_nat5 (r1 *! u64 19, r2 *! u64 19, r3 *! u64 19, r4 *! u64 19, r0)) % prime)
let lemma_fmul5 f1 r =
let (f10, f11, f12, f13, f14) = f1 in
let (r0, r1, r2, r3, r4) = r in
assert ((as_nat5 f1 * as_nat5 r) % prime ==
(v f10 + v f11 * pow51 + v f12 * pow51 * pow51 + v f13 * pow51 * pow51 * pow51 +
v f14 * pow51 * pow51 * pow51 * pow51) * as_nat5 r % prime);
lemma_mul5_distr_r (v f10) (v f11 * pow51) (v f12 * pow51 * pow51)
(v f13 * pow51 * pow51 * pow51) (v f14 * pow51 * pow51 * pow51 * pow51) (as_nat5 r);
lemma_fmul5_1 f1 r;
lemma_fmul5_2 f1 r;
lemma_fmul5_3 f1 r;
lemma_fmul5_4 f1 r;
FStar.Math.Lemmas.lemma_mod_mul_distr_l (as_nat5 f1) (as_nat5 r) prime;
FStar.Math.Lemmas.lemma_mod_mul_distr_r (as_nat5 f1 % prime) (as_nat5 r) prime
val lemma_smul_felem5:
u1:uint64
-> f2:felem5
-> Lemma (
let (f20, f21, f22, f23, f24) = f2 in
v u1 * as_nat5 f2 == v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_felem5 u1 f2 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// assert (as_nat5 f2 == v f20 + v f21 * pow51 + v f22 * pow51 * pow51 +
// v f23 * pow51 * pow51 * pow51 + v f24 * pow51 * pow51 * pow51 * pow51);
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_smul_add_felem5:
u1:uint64
-> f2:felem5
-> acc1:felem_wide5
-> Lemma (let (f20, f21, f22, f23, f24) = f2 in
let (o0, o1, o2, o3, o4) = acc1 in
wide_as_nat5 acc1 + uint_v u1 * as_nat5 f2 ==
v o0 + v o1 * pow51 + v o2 * pow51 * pow51 +
v o3 * pow51 * pow51 * pow51 + v o4 * pow51 * pow51 * pow51 * pow51 +
v u1 * v f20 + v u1 * v f21 * pow51 +
v u1 * v f22 * pow51 * pow51 + v u1 * v f23 * pow51 * pow51 * pow51 +
v u1 * v f24 * pow51 * pow51 * pow51 * pow51)
let lemma_smul_add_felem5 u1 f2 acc1 = ()
// let (f20, f21, f22, f23, f24) = f2 in
// let (o0, o1, o2, o3, o4) = acc1 in
// lemma_mul5_distr_l (v u1) (v f20) (v f21 * pow51) (v f22 * pow51 * pow51)
// (v f23 * pow51 * pow51 * pow51) (v f24 * pow51 * pow51 * pow51 * pow51)
val lemma_carry51:
l:uint64
-> cin:uint64
-> Lemma
(requires felem_fits1 l 2 /\ felem_fits1 cin 8190)
(ensures (let l0 = (l +! cin) &. mask51 in
let l1 = (l +! cin) >>. 51ul in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ v l1 < pow2 13))
let lemma_carry51 l cin =
let l' = l +! cin in
let l0 = l' &. mask51 in
let l1 = l' >>. 51ul in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51);
FStar.Math.Lemmas.pow2_minus 64 51
val lemma_carry51_wide:
#m:scale64{m < 8192}
-> l:uint128{felem_wide_fits1 l m}
-> cin:uint64
-> Lemma (
let l' = l +! to_u128 cin in
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
v l + v cin == v l1 * pow2 51 + v l0 /\
felem_fits1 l0 1 /\ felem_fits1 l1 (m + 1))
let lemma_carry51_wide #m l cin =
let l' = l +! to_u128 cin in
//assert_norm (8192 * pow51 * pow51 == pow2 115);
//assert (v l' < pow2 115);
let l0 = (to_u64 l') &. mask51 in
let l1 = to_u64 (l' >>. 51ul) in
mod_mask_lemma (to_u64 l') 51ul;
assert (v (mod_mask #U64 #SEC 51ul) == v mask51);
FStar.Math.Lemmas.pow2_modulo_modulo_lemma_1 (v l') 51 64;
FStar.Math.Lemmas.euclidean_division_definition (v l') (pow2 51)
val lemma_carry5_simplify:
c0:uint64 -> c1:uint64 -> c2:uint64 -> c3:uint64 -> c4:uint64 ->
t0:uint64 -> t1:uint64 -> t2:uint64 -> t3:uint64 -> t4:uint64 ->
Lemma
((v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51) % prime ==
(v t0 + v c4 * 19 + v t1 * pow51 + v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 + v t4 * pow51 * pow51 * pow51 * pow51) % prime)
let lemma_carry5_simplify c0 c1 c2 c3 c4 t0 t1 t2 t3 t4 =
assert_norm (pow51 = pow2 51);
assert (
v c0 * pow2 51 + v t0 +
(v c1 * pow2 51 + v t1 - v c0) * pow51 +
(v c2 * pow2 51 + v t2 - v c1) * pow51 * pow51 +
(v c3 * pow2 51 + v t3 - v c2) * pow51 * pow51 * pow51 +
(v c4 * pow2 51 + v t4 - v c3) * pow51 * pow51 * pow51 * pow51 ==
v t0 + v t1 * pow51 + v t2 * pow51 * pow51 + v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51 + v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * pow2 51 * pow51 * pow51 * pow51 * pow51) prime;
lemma_mul_assos_6 (v c4) (pow2 51) pow51 pow51 pow51 pow51;
assert_norm (pow2 51 * pow51 * pow51 * pow51 * pow51 = pow2 255);
FStar.Math.Lemmas.lemma_mod_mul_distr_r (v c4) (pow2 255) prime;
lemma_prime ();
assert_norm ((v c4 * pow2 255) % prime == (v c4 * 19) % prime);
FStar.Math.Lemmas.lemma_mod_plus_distr_r
(v t0 + v t1 * pow51 +
v t2 * pow51 * pow51 +
v t3 * pow51 * pow51 * pow51 +
v t4 * pow51 * pow51 * pow51 * pow51)
(v c4 * 19) prime
val lemma_load_felem5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures as_nat5 f == BSeq.nat_from_intseq_le u64s)
let lemma_load_felem5 f u64s =
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
assert_norm (pow51 = pow2 51);
FStar.Math.Lemmas.euclidean_division_definition (v s0) (pow2 51);
assert_norm (pow2 13 * pow2 51 = pow2 64);
assert_norm (pow2 51 * pow2 51 = pow2 38 * pow2 64);
FStar.Math.Lemmas.euclidean_division_definition (v s1) (pow2 38);
assert_norm (pow2 26 * pow2 51 * pow2 51 = pow2 128);
assert_norm (pow2 51 * pow2 51 * pow2 51 = pow2 25 * pow2 128);
FStar.Math.Lemmas.euclidean_division_definition (v s2) (pow2 25);
assert_norm (pow2 39 * pow2 51 * pow2 51 * pow2 51 = pow2 192);
assert_norm (pow2 51 * pow2 51 * pow2 51 * pow2 51 = pow2 12 * pow2 192);
FStar.Math.Lemmas.euclidean_division_definition (v s3) (pow2 12);
assert (as_nat5 f == v s0 + v s1 * pow2 64 + v s2 * pow2 128 + v s3 * pow2 192);
Hacl.Impl.Curve25519.Lemmas.lemma_nat_from_uints64_le_4 u64s;
assert_norm (pow2 64 * pow2 64 = pow2 128);
assert_norm (pow2 64 * pow2 64 * pow2 64 = pow2 192)
val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1)) | false | false | Hacl.Spec.Curve25519.Field51.Lemmas.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_load_felem_fits5:
f:felem5
-> u64s:LSeq.lseq uint64 4
-> Lemma
(requires (
let open Lib.Sequence in
let (f0, f1, f2, f3, f4) = f in
let (s0, s1, s2, s3) = (u64s.[0], u64s.[1], u64s.[2], u64s.[3]) in
v s3 < pow2 63 /\
v f0 == v s0 % pow2 51 /\
v f1 == v s0 / pow2 51 + (v s1 % pow2 38) * pow2 13 /\
v f2 == v s1 / pow2 38 + (v s2 % pow2 25) * pow2 26 /\
v f3 == v s2 / pow2 25 + (v s3 % pow2 12) * pow2 39 /\
v f4 == v s3 / pow2 12))
(ensures felem_fits5 f (1, 1, 1, 1, 1)) | [] | Hacl.Spec.Curve25519.Field51.Lemmas.lemma_load_felem_fits5 | {
"file_name": "code/curve25519/Hacl.Spec.Curve25519.Field51.Lemmas.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: Hacl.Spec.Curve25519.Field51.Definition.felem5 -> u64s: Lib.Sequence.lseq Lib.IntTypes.uint64 4
-> FStar.Pervasives.Lemma
(requires
(let _ = f in
(let FStar.Pervasives.Native.Mktuple5 #_ #_ #_ #_ #_ f0 f1 f2 f3 f4 = _ in
let _ = u64s.[ 0 ], u64s.[ 1 ], u64s.[ 2 ], u64s.[ 3 ] in
(let FStar.Pervasives.Native.Mktuple4 #_ #_ #_ #_ s0 s1 s2 s3 = _ in
Lib.IntTypes.v s3 < Prims.pow2 63 /\
Lib.IntTypes.v f0 == Lib.IntTypes.v s0 % Prims.pow2 51 /\
Lib.IntTypes.v f1 ==
Lib.IntTypes.v s0 / Prims.pow2 51 +
(Lib.IntTypes.v s1 % Prims.pow2 38) * Prims.pow2 13 /\
Lib.IntTypes.v f2 ==
Lib.IntTypes.v s1 / Prims.pow2 38 +
(Lib.IntTypes.v s2 % Prims.pow2 25) * Prims.pow2 26 /\
Lib.IntTypes.v f3 ==
Lib.IntTypes.v s2 / Prims.pow2 25 +
(Lib.IntTypes.v s3 % Prims.pow2 12) * Prims.pow2 39 /\
Lib.IntTypes.v f4 == Lib.IntTypes.v s3 / Prims.pow2 12)
<:
Type0)
<:
Type0)) (ensures Hacl.Spec.Curve25519.Field51.Definition.felem_fits5 f (1, 1, 1, 1, 1)) | {
"end_col": 25,
"end_line": 604,
"start_col": 2,
"start_line": 577
} |
Prims.Tot | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | [
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True | val linv_ctx (a: LSeq.lseq uint64 0) : Type0
let linv_ctx (a: LSeq.lseq uint64 0) : Type0 = | false | null | false | True | {
"checked_file": "Hacl.Impl.P256.Group.fst.checked",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.PointDouble.fsti.checked",
"Hacl.Impl.P256.PointAdd.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Group.fst"
} | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Prims.l_True"
] | [] | module Hacl.Impl.P256.Group
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BE = Hacl.Impl.Exponentiation.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
open Hacl.Impl.P256.Point
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0" | false | false | Hacl.Impl.P256.Group.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val linv_ctx (a: LSeq.lseq uint64 0) : Type0 | [] | Hacl.Impl.P256.Group.linv_ctx | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Group.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | a: Lib.Sequence.lseq Lib.IntTypes.uint64 0 -> Type0 | {
"end_col": 50,
"end_line": 23,
"start_col": 46,
"start_line": 23
} |
Prims.Tot | val point_zero : BE.lone_st U64 12ul 0ul mk_to_p256_comm_monoid | [
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_zero ctx one =
let h0 = ST.get () in
SL.to_aff_point_at_infinity_lemma ();
make_point_at_inf one | val point_zero : BE.lone_st U64 12ul 0ul mk_to_p256_comm_monoid
let point_zero ctx one = | false | null | false | let h0 = ST.get () in
SL.to_aff_point_at_infinity_lemma ();
make_point_at_inf one | {
"checked_file": "Hacl.Impl.P256.Group.fst.checked",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.PointDouble.fsti.checked",
"Hacl.Impl.P256.PointAdd.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Group.fst"
} | [
"total"
] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"FStar.UInt32.__uint_to_t",
"Hacl.Impl.P256.Point.make_point_at_inf",
"Prims.unit",
"Spec.P256.Lemmas.to_aff_point_at_infinity_lemma",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | module Hacl.Impl.P256.Group
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BE = Hacl.Impl.Exponentiation.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
open Hacl.Impl.P256.Point
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold
let refl (p:LSeq.lseq uint64 12{point_inv_seq p}) : GTot S.aff_point =
S.to_aff_point (from_mont_point (as_point_nat_seq p))
inline_for_extraction noextract
let mk_to_p256_comm_monoid : BE.to_comm_monoid U64 12ul 0ul = {
BE.a_spec = S.aff_point;
BE.comm_monoid = S.mk_p256_comm_monoid;
BE.linv_ctx = linv_ctx;
BE.linv = point_inv_seq;
BE.refl = refl;
}
inline_for_extraction noextract
val point_add : BE.lmul_st U64 12ul 0ul mk_to_p256_comm_monoid
let point_add ctx x y xy =
let h0 = ST.get () in
SL.to_aff_point_add_lemma
(from_mont_point (as_point_nat h0 x)) (from_mont_point (as_point_nat h0 y));
Hacl.Impl.P256.PointAdd.point_add xy x y
inline_for_extraction noextract
val point_double : BE.lsqr_st U64 12ul 0ul mk_to_p256_comm_monoid
let point_double ctx x xx =
let h0 = ST.get () in
SL.to_aff_point_double_lemma (from_mont_point (as_point_nat h0 x));
Hacl.Impl.P256.PointDouble.point_double xx x
inline_for_extraction noextract | false | false | Hacl.Impl.P256.Group.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_zero : BE.lone_st U64 12ul 0ul mk_to_p256_comm_monoid | [] | Hacl.Impl.P256.Group.point_zero | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Group.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Exponentiation.Definitions.lone_st Lib.IntTypes.U64
12ul
0ul
Hacl.Impl.P256.Group.mk_to_p256_comm_monoid | {
"end_col": 23,
"end_line": 61,
"start_col": 24,
"start_line": 58
} |
Prims.GTot | val refl (p: LSeq.lseq uint64 12 {point_inv_seq p}) : GTot S.aff_point | [
{
"abbrev": false,
"full_module": "Hacl.Impl.P256.Point",
"short_module": null
},
{
"abbrev": true,
"full_module": "Spec.P256.Lemmas",
"short_module": "SL"
},
{
"abbrev": true,
"full_module": "Spec.P256",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.Exponentiation.Definitions",
"short_module": "BE"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.P256",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let refl (p:LSeq.lseq uint64 12{point_inv_seq p}) : GTot S.aff_point =
S.to_aff_point (from_mont_point (as_point_nat_seq p)) | val refl (p: LSeq.lseq uint64 12 {point_inv_seq p}) : GTot S.aff_point
let refl (p: LSeq.lseq uint64 12 {point_inv_seq p}) : GTot S.aff_point = | false | null | false | S.to_aff_point (from_mont_point (as_point_nat_seq p)) | {
"checked_file": "Hacl.Impl.P256.Group.fst.checked",
"dependencies": [
"Spec.P256.Lemmas.fsti.checked",
"Spec.P256.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Impl.P256.PointDouble.fsti.checked",
"Hacl.Impl.P256.PointAdd.fsti.checked",
"Hacl.Impl.P256.Point.fsti.checked",
"Hacl.Impl.Exponentiation.Definitions.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.P256.Group.fst"
} | [
"sometrivial"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Hacl.Impl.P256.Point.point_inv_seq",
"Spec.P256.PointOps.to_aff_point",
"Hacl.Impl.P256.Point.from_mont_point",
"Hacl.Impl.P256.Point.as_point_nat_seq",
"Spec.P256.PointOps.aff_point"
] | [] | module Hacl.Impl.P256.Group
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module BE = Hacl.Impl.Exponentiation.Definitions
module S = Spec.P256
module SL = Spec.P256.Lemmas
open Hacl.Impl.P256.Point
#set-options "--z3rlimit 50 --fuel 0 --ifuel 0"
unfold
let linv_ctx (a:LSeq.lseq uint64 0) : Type0 = True
unfold | false | false | Hacl.Impl.P256.Group.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val refl (p: LSeq.lseq uint64 12 {point_inv_seq p}) : GTot S.aff_point | [] | Hacl.Impl.P256.Group.refl | {
"file_name": "code/ecdsap256/Hacl.Impl.P256.Group.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Lib.Sequence.lseq Lib.IntTypes.uint64 12 {Hacl.Impl.P256.Point.point_inv_seq p}
-> Prims.GTot Spec.P256.PointOps.aff_point | {
"end_col": 55,
"end_line": 27,
"start_col": 2,
"start_line": 27
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.